Un tutoriel Gtk2-Perl

GTK+ (le GIMP Toolkit) est une bibliothèque pour créer des interfaces graphiques. Son nom provient d'ailleurs du fait qu'elle a été initialement écrite pour le fameux GNU Image Manipulation Project (GIMP). Elle est placée sous la licence LPGL, ainsi vous pouvez développer des logiciels libres, ou même des logiciels commerciaux payants sans avoir à dépenser quoi que ce soit en licences ou en royalties. GTK+ est elle-même basée sur d'autres bibliothèques qui sont :

• GDK : un encapsulateur de la Xlib ;
• gtk-pixbuf : pour manipuler les images ;
• Pango : pour l'internationalisation ;
• gobject : qui définit le système de type sur lequel est basé GTK;
• gmodule : qui est utilisé pour charger des extensions à la volée ;
• Glib : une bibliothèque d'utilitaires indispensables ;
• Xlib : sur laquel est basée GDK ;
• Xext : qui contient du code pour les pixmaps à mémoire partagée et autres extensions X ;
• math : utilisée par GTK à plusieurs occasions.

L'un des avantages d'avoir une bibliothèque écrite en C est que la plupart des langages sont capables d'avoir une interface avec les bibliothèques C, rendant GTK disponible pour plusieurs langages, comme C-, Perl, Python, Eiffel et beaucoup d'autres. Les créateurs de GTK+ sont :

• Peter Mattis ;
• Spencer Kimball ;
• Josh MacDonald. Actuellement, GTK+ est maintenu par :
• Owen Taylor ;
• Tim Janik.

Le site officiel de GTK+ est http://www.gtk.org.

Gtk2-Perl est donc l'encapsulateur qui permet d'utiliser la librairie GTK+, version 2, en Perl. Gtk2-Perl est sous la licence LGPL, ce qui signifie qu'il possède les mêmes restrictions et les mêmes libertés que Perl.

Bien qu'écrite en C, GTK+ est implémentée selon le modèle de programmation objet, ce qui implique beaucoup de rigueur de la part des développeurs. En effet, pour mettre en place la notion d'héritage et d'objet, il a été développé un système de type et une méthodologie précise dont on a pas à se préoccuper avec un langage orienté objet.

Et c'est là que le travail de la Gtk2-Perl TEAM est magique ! Tout le côté désagréable de gestion de type est effectué par le module et non par le programmeur. Ainsi écrire un programme avec le module Gtk2-Perl se fait de la même manière que n'importe quel programme Perl écrit selon le modèle de programmation objet. La Gtk2-Perl Team que l'on peut contacter sur gtk-Perl-list@lists.gnome.org :

• muppet scott at asofyet dot org ;
• Ross McFarland rwmcfa1 at neces dot com ;
• Torsten Schoenfeld kaffeetisch at web dot de ;
• Marc Lehmann pcg at goof dot com ;
• Goran Thyni goran at kirra dot net ;
• Joern Reder joern at zyn dot de ;
• Chas Owens alas at wilma dot widomaker dot com ;
• Guillaume Cottenceau gc at mandrakesoft dot com.

Ont également participé en envoyant des patchs :

• René Seindal rene at seindal dot dk ;
• Tom Hargreaves hex at freezone dot co dot uk ;
• Thierry Vignaud tvignaud at mandrakesoft dot com ;
• James Curbo hannibal at adtrw dot org ;
• Dr. Michael Langner langner at fiz-chemie dot de ;
• Anuradha Ratnaweera Aratnaweera at virtusa dot com.

Le site officiel de GTK+ est http://gtk2-perl.sourceforge.net/.

Il est vrai que le module est fidèle à la bibliothèque C donc la documentation C est valable à 95 %. Mais il faut bien penser à ceux qui ne maîtrisent pas le langage C et encore moins la langue de Shakespeare ! Ce tutoriel ne se veut qu'une introduction en français, mais en aucun cas un manuel de référence. Votre trouverez d'ailleurs ce dernier au format pod sur le site officiel http://www.gtk2-Perl.sourceforge.net. à mon avis, une fois que l'on a assimilé quelques bases en Gtk2-Perl, la consultation de la documentation C est naturelle. Ce tutoriel se concentre sur les liens entre Perl et GTK c'est pourquoi une connaissance approfondie de Perl n'est pas nécessaire, mais est préférable. Je prendrais rarement le temps d'expliquer des détails sur Perl donc si vous n'êtes pas sûr de vos compétences en Perl, ayez à portée de main votre guide de référence Perl préféré. Si quelqu'un veut aider à l'élaboration de ce tutoriel, qu'il se fasse connaître en me contactant :

J'espère que mes exemples seront lisibles et compréhensibles pour les novices en Perl, les experts et n'importe qui entre les deux. Ce document est « un travail en cours ». J'aimerais beaucoup savoir si vous avez eu des difficultés à apprendre Gtk2-Perl à partir de ce document et j'apprécierais également toute suggestion qui vise à améliorer le document. Si vous êtes un programmeur expérimenté en Gtk2-Perl, ce qui n'est pas mon cas, faîtes-moi savoir si j'ai commis des erreurs, s'il est des éléments que j'ai délaissés ou mal expliqués. Les principales sources de ce document sont :

• l'excellent GTK-Tutoriel : http://www.gtk.org/documentation.php ;
• les exemples qui sont fournis avec les sources du module.
• le site http://gtk2-Perl.sourceforge.net où vous trouverez tout sur Gtk2-Perl donc incontournable… mais il vaut mieux parler anglais. La coloration syntaxique a été réalisée à l'aide du programme highlight.

La première chose bien évidemment est d'avoir une installation de Gtk2 qui fonctionne, une version récente est recommandée. Ensuite , il faut télécharger et installer dans l'ordre suivant les sources de :

• Perl-ExtUtils-Depends ;
• Perl-ExtUtils-PkgConfig ;
• Perl-Glib ;
• Perl-Gtk2 .

Vous pouvez toujours avoir les dernières versions à partir du site http://gtk2-perl.sourceforge.net/.

L'installation ne devrait pas poser de problème. Pour chacun des modules, il suffit de faire :

Perl Makefile.PL
make
make install

Maintenant, voyons si nous ne pouvons pas cheminer à travers le programme et lui donner du sens.

use Gtk2 '-init'; doit être inclus dans tout programme Gtk2-Perl. Cela permet à Perl d'utiliser les variables, les fonctions, les structures, etc. définies par GTK. Dans le même temps, cela initialise le module Gtk2 et met en place quelques éléments comme l'aspect par défaut, la couleur et les déclencheurs de signaux par défaut. Cela peut-être facilement combiné avec d'autres directives use comme use strict ;.

Les variables TRUE et FALSE correspondent à des valeurs booléennes. Elles sont définies pour rendre le code plus lisible.

Gtk::Window->new() 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. Les autres widgets de l'application seront placés à l'intérieur. Vous pouvez avoir plusieurs fenêtres par programme. L'argument indique à X le type de fenêtre dont il s'agit. Les fenêtres toplevel 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 set_border_width() prendra un conteneur (comme une fenêtre) et placera de l'espace autour du contenu. 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 fait ? GTK redimensionnera automatiquement les widgets sauf si vous lui dites de ne pas le faire (cela inclut 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éfinis par défaut. Donnez juste la disposition à GTK et laissez-le faire le reste. Pour plus d'informations sur les boutons voir la section les concernant.

signal_connect relie un évènement ou un signal à une routine. Un exemple serait d'appuyer sur le bouton de la souris. En termes 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.

Dans notre exemple, le premier argument de signal_connect est une chaine indiquant l'évènement que nous voulons 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.

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

Gtk2->main déclenche le processus de contrôle des évènements GTK. Il s'agit d'une ligne que vous verrez dans toutes les applications Gtk2-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 Gtk2->main_quit().

Une interface graphique est composée d'éléments (fenêtre, cadres, boutons…) appelés widgets. Ceux-ci peuvent émettre des signaux. Ce ne sont pas les mêmes que les signaux d'un système Unix et ils ne sont pas implémentés en les utilisant bien que la terminologie soit presque identique. Quand on clique sur un bouton, il émet le signal 'clicked'. Gtk en prend note en le plaçant dans une liste. Si on veut que ce clic déclenche une action, il faut relier ce signal à une fonction qui sera appelée dès que le signal sera émis. En simplifiant, il faut considérer le programme comme un régulateur qui centralise tous les évènements qui se produisent et à qui on peut demander de nous prévenir si tel ou tel évènement a eu lieu.

Pour relier un signal à une fonction, on procède ainsi :

$object->signal_connect( 'signal_name', \&signal_func );
$object->signal_connect( signal_name => \&signal_func );
$object->signal_connect( 'signal_name', \&signal_func, $donnee_optionnelle ... );
$object->signal_connect( 'signal_name', \&signal_func, @donnees_optionnelles );

En Perl, les deux premières formes sont identiques ainsi que les deux suivantes, car Perl envoie tous les arguments sous la forme d'une seule liste de scalaires. Bien sûr, vous pouvez envoyer autant d'éléments par liste que vous le désirez.

La variable à gauche du signal_connect() est le widget qui émettra le signal. Le premier argument est une chaine de caractères représentant le signal dont vous aimeriez enregistrer le rappel de signal. Le second argument est la routine que vous voulez appeler. Cette routine est appelée rappel de signal ou fonction de rappel. Si vous passez des arguments à la routine, vous les précisez en les ajoutant à la fin de la liste d'arguments. Tout ce qui est après le second argument est passé en tant que liste, c'est pourquoi vous pouvez vous permettre de passer autant d'arguments que vous le souhaitez.

Si vous ne comprenez pas les références Perl, souvenez-vous que les routines sont précédées par un \& et que vous ne pouvez pas placer des parenthèses après le nom de la routine.

Pour les rappels de signaux associés avec uniquement un signal et composés de quelques lignes, il est courant de voir quelque chose comme ceci :

$object->signal_connect( "signal_name", sub { faire_quelque_chose; } );

Une routine est habituellement définie par :

fonction_de_rappel {
    my ( $widget, $donnee ) = @_;
    ...;
}

Le premier argument envoyé à un rappel de signal sera toujours le widget émetteur et le reste des arguments sont des données optionnelles envoyées par la fonction signal_connect(). Souvenez-vous que Perl ne vous oblige pas à déclarer ou à utiliser les arguments envoyés à une routine.

E n plus du mécanisme des signaux décrit précédemment, il y a un ensemble d'évènements qui reflètent les mécanismes des évènements X. Par exemple, si l'utilisateur ferme la fenêtre principale, c'est le gestionnaire de fenêtres qui enverra un message à l'application.

Les évènements suivants peuvent également être reliés à une fonction de rappel :

Afin de connecter une fonction de rappel à l'un de ces évènements, on utilise signal_connect() de la même manière que pour connecter un signal, sauf que l'on écrit le nom de l'évènement à la place du nom du signal. Le dernier argument passé au rappel de signal est une structure d'évènement ainsi au début de votre fonction, vous devriez dire :

my ( $widget, $évènement, $donnee ) = @_;

Ou si vous voulez passer un ensemble de données :

my ( $widget, @data ) = @_;
my $event = shift(@data);

Un évènement est une structure qui comporte plusieurs champs. Il y a en particulier le champ type qui est une chaine de caractères qui identifie l'évènement et qui appartient à la liste suivante :

Il y a également le champ button qui contient un nombre indiquant le bouton pressé (typiquement 1, 2 ou 3) et le champ key qui indique la touche pressée (s'il y en a une). Cela permet de déterminer facilement la cause d'un évènement. Par exemple, cela fut-il causé par un bouton pressé ? si oui, lequel ?

sub some_event {
    my ( $widget, @donnees ) = @_;
    my $évènement = shift(@donnees);
    if (    ( defined( $evenement->type ) )
        and ( $evenement->type eq 'button_press' ) )
    {
        if ( $évènement->button == 3 ) {

            #click_droit
        }
        else {
            # pas_un_click_droit
        }
    }
}

Gardez à l'esprit que le code précédent ne fonctionne que si le rappel est lié à l'un des évènements mentionnés ci-dessus. Les signaux n'envoient pas une structure d'évènement ainsi, à moins que vous ne connaissiez exactement le nombre d'arguments envoyés, vous n'avez pas besoin de l'information sur la structure d'un évènement. Je milite pour ne pas connecter un signal et un évènement au même retour.

La valeur de retour de la fonction signal_connect() est un « tag » qui identifie la fonction de rappel. Vous pouvez avoir autant de rappels par signal ou par objet que vous le souhaitez et ils seront exécutés les uns après les autres dans l'ordre où ils ont été attachés.

II-E-1. Émettre un signal▲

$widget->signal_emit($id);
$widget->signal_emit_by_name($nom_du_signal);

II-E-2. Supprimer des retours▲

$widget->signal_disconnect($id);

$widget->signal_handlers_destroy();

II-E-3. Désactiver temporairement des gestionnaires▲

$widget->signal_handler_block($callback_id);
$widget->signal_handler_block_by_func( \&callback, $donnee );
$widget->signal_handler_block_by_data($donnee);
$widget->signal_handler_unblock($callback_id);
$widget->signal_handler_unblock_by_func( \&callback, $donnee );
$widget->signal_handler_unblock_by_data($donnee);

II-E-4. Connecter ou déconnecter des gestionnaires▲

$id = $object->signal_connect( $nom_du_signal, \&function, @optional_data );
$id = $object->signal_connect_after( $nom_du_signal, \&function, @optional_data );
$id = $object->signal_connect_object( $nom_du_signal, \&function, $slot_object );
$id = $object->signal_connect_object_after( $nom_du_signal, \&function, slot_object );

#Je ne suis pas sûr de celle-là
$id =
  $object->signal_connect_full( $name, \&function, $callback_marshal, @optional_data, \&destroy_function,
    $object_signal, $after );

#Je ne suis pas sûr de celles-là non plus
$id = $object->signal_connect_object_while_alive( $signal, \&function, $alive_object );
$id = $object->signal_connect_while_alive( $signal, \&function, @optional_data, $alive_object );
$object->signal_disconnect($id);
$object->signal_disconnect_by_func( \&function, @optional_data );

#!/usr/bin/Perl -w
use strict;
use Gtk2 '-init';

# Variables convenables pour vrai et faux
use constant TRUE  => 1;
use constant FALSE => 0;

# Création d'une fenêtre
my $window = Gtk2::Window->new('toplevel');

# On définit une bordure de 15 pixels
$window->set_border_width(15);

# On déclare le titre de la fenêtre
$window->set_title('Salut les boutons !');

# On relie l'évènement delete event à une fonction de rappel à qui on
# passe comme argument une chaine de caractère
$window->signal_connect( 'delete event', \&CloseWindow, "Puisqu'il faut partir..." );

# Le signal "destroy" sera émis parce que la fonction de rappel "CloseWindow"
# renvoie FALSE.
$window->signal_connect( 'destroy', \&DestroyWindow );

# Création d'une boite dans laquelle on placera les boutons. Nous verrons
# en détail les comportements des boites dans le chapitre sur les conteneurs.
# Une boite n'est pas visible. Elle est juste utile pour ranger les widgets
# qu'elle contient.
my $box = Gtk2::HBox->new( FALSE, 0 );

# On place la boite dans la fenêtre.
$window->add($box);

# Création d'un bouton qui s'appellera 'bouton 1'
my $button1 = Gtk2::Button->new("Bouton 1");

# On relie le signal "clicked" à la fonction de rappel "rappel"
# à qui on passe comme argument la chaine de caractère "bouton 1".
$button1->signal_connect( 'clicked', \&rappel, "bouton 1" );

# On place le bouton 1 dans notre boite
$box->pack_start( $button1, TRUE, TRUE, 0 );

# On montre le bouton
$button1->show;

# On refait la même chose pour placer un second bouton dans la boite
my $button2 = Gtk2::Button->new("Bouton 2");
$button2->signal_connect( 'clicked', \&rappel, "bouton 2" );
$box->pack_start( $button2, TRUE, TRUE, 0 );
$button2->show;

# On montre la boite
$box->show;

# On montre la fenêtre
$window->show();

# On lance la boucle principale.
Gtk2->main;
### La fonction de rappel qui est appelé quand on a cliqué sur un bouton.
sub rappel {
    my ( $widget, $pressed_button ) = @_;
    print("Vous avez pressé le $pressed_button ! !\n");
}
### La fonction de rappel appelé par l'évènement "delete event".
sub CloseWindow {
    my ( $widget, $event, $message ) = @_;

    # On récupère le nom de l'évènement
    my $name = $event->type;
    print "L'évènement $name s'est produit !\n";
    print "$message \n";
    return FALSE;
}
### La fonction de rappel pour fermer la fenêtre
sub DestroyWindow {
    Gtk2->main_quit;
    return FALSE;
}

Un bon exercice serait d'ajouter un troisième bouton « quitter ». Vous pourriez également jouer avec les options de le méthode pack_start() quand vous aurez lu le chapitre suivant. Essayez de redimensionner la fenêtre et observez son comportement.

Le rangement est fait en créant des boites puis en regroupant les widgets à l'intérieur. Ces boites sont des conteneurs invisibles dans lesquelles on peut regrouper les widgets. Il en existe deux sortes : la boite horizontale et la boite verticale. En rangeant les widgets dans une boite horizontale, les objets sont insérés de la gauche vers la droite ou de la droite vers la gauche en fonction de l'appel utilisé. Pour une boite verticale, le rangement se fait de bas en haut ou vice-versa. Vous pouvez utiliser des combinaisons en rangeant des boites à l'intérieur d'autres boites, ou à côté afin de produire l'effet désiré.

Pour créer une nouvelle boite horizontale ou verticale :

$box = Gtk2::HBox->new( $homogeneous, $spacing );
$box = Gtk2::VBox->new( $homogeneous, $spacing );

Si $homogeneous est une valeur vraie alors tous les widgets rangés à l'intérieur disposeront du même espace. $spacing est l'espace en pixels qu'il faut laisser entre les widgets.

Les fonctions suivantes sont utilisées pour placer les objets dans les boites :

$box->pack_start( $child, $expand, $fill, $padding );
$box->pack_end( $child, $expand, $fill, $padding );

La fonction pack_start() commence à remplir une VBox par le haut et continue vers le bas. Pour une HBox, elle commence par la gauche et continue vers la droite. pack_end() fera le contraire. Ces fonctions nous permettent juste de justifier à droite ou à gauche la position des widgets et peuvent être mélangées pour obtenir l'effet désiré. L'objet ajouté peut-être ou bien un conteneur ou bien un widget. En fait, de nombreux widgets sont eux-mêmes des conteneurs (les boutons par exemple, mais nous n'utilisons en général qu'un label ou une icône à l'intérieur des boutons). Comme vous l'avez peut-être deviné, l'argument $child est le widget à placer dans la boite. Enfin $padding est un espace donné en pixel qui entourera l'enfant.

Si l'argument $expand est une valeur vraie alors les widgets seront disposés dans la boite pour remplir l'espace qui leurs est alloué. Déclarer $expand comme valeur fausse vous permettra de faire des justifications à droite et à gauche de vos widgets. Noter que déclarer $expand vraie pour une boite revient à déclarer $expand vraie pour chaque widget.

Si l'argument $fill est une valeur vraie alors tout espace vide est alloué aux objets eux-mêmes. Autrement l'espace vide est un emballage dans la boite autour des objets. Cela a de l'effet uniquement si l'argument $expand est vrai.

En utilisant ces appels, GTK sait où vous voulez placer vos widgets et peut ainsi les redimensionner ou faire d'autres choses sympathiques. Comme vous l'imaginez, cette méthode nous donne une certaine flexibilité quand on crée et place des widgets.

Vous avez créé une boite avec une valeur vraie pour l'argument $homogeneous. Par exemple :

$box = new Gtk2::HBox( TRUE, 0 );
$box = new Gtk2::VBox( TRUE, 0 );

Dans ce cas, tous les widgets contenus dans la boite seront dimensionnés en fonction du plus grand et l'argument $expand$ n'a pas d'intérêt.

Si $fill est une valeur vraie alors tous les widgets contenus ont la même taille et remplissent l'espace qui leur est alloué.

Si $fill est une valeur fausse alors les widgets gardent leurs tailles respectives et sont également répartis dans le conteneur.

Vous avez créé une boite avec une valeur vraie pour l'argument $homogeneous. Par exemple :

$box = new Gtk2::HBox( FALSE, 0 );
$box = new Gtk2::VBox( FALSE, 0 );

Si $expand est une valeur fausse alors la valeur de $fill n'a aucun intérêt. Les widgets auront alors leur propre taille et ne rempliront pas l'espace.

Si $expand est une valeur vraie alors les widgets seront étirés dans la boite. Si $fill est fausse, alors les widgets gardent leur taille naturelle.

En revanche, si $fill est une valeur vraie alors les widgets remplissent la boite.

Le rangement dans les boites peut être déroutant au début. Il y a beaucoup d'options et il n'est pas immédiatement évident de les arranger entre elles. En fait, il y a cinq styles de base différents. Ces cinq styles sont ceux qui sont illustrés ci-dessus.

Chaque ligne de l'exemple contient une boite horizontale avec plusieurs boutons. L'appel pour ranger est un raccourci pour regrouper chaque bouton dans une boite. Chaque bouton est placé dans la boite de la même manière (les arguments sont passés à la fonction pack_start()). C'est une forme raccourcie de pack_start() et de pack_end() qui déclare $expand vraie, $fill vraie et $padding=0.

Ces fonctions sont :

$box->pack_start_defaults($widget);
$box->pack_end_defaults($widget);

La valeur $homogeneous de la boite peut être modifiée en utilisant la fonction :

$box->set_homogeneous($homogeneous);

De même pour la valeur $spacing :

$box->set_spacing($spacing);

Si vous voulez déplacer un enfant, utilisez :

$box->reorder_child($child,$position);

$child est le widget à déplacer et $position est la position à changer en partant de 0. Si vous voulez connaître l'ordre actuel, regardez la liste fournie par l'appel à la fonction sur les conteneurs children().

Si vous voulez changer un regroupement d'enfants, vous pouvez utiliser :

$box>set_child_packing($widget,$expand,$fill,$padding,$pack_type);

Les arguments sont les mêmes que pour les fonctions pack_start() et pack_end() à l'exception de $pack_type qui est soit 'start' soit 'end'.

Quelle est la différence entre l'espace (spacing), déclaré quand la boite est créée, et l'emballage (padding), déclaré quand les éléments sont rangés ? L'espace est ajouté entre les objets et l'emballage est ajouté de chaque côté de l'objet.

Tout d'abord, la fonction qui permet de créer une table :

$table = Gtk2::Table->new($nb_lignes, $nb_colonnes, $homogeneous);

Le premier argument est le nombre de lignes et le second, évidemment le nombre de colonnes. L'argument $homogeneous sert à déterminer la manière dont les cases de la table sont dimensionnées. Si $homogeneous est une valeur vraie, les cases sont dimensionnées en fonction de la plus grande ? Si $homogeneous est une valeur fausse, la taille de la case est dictée par le plus petit widget de la ligne et le plus large de la colonne.

Les colonnes et les lignes sont disposées de 0 à n où n est le nombre spécifié à l'appel new Gtk2::Table(). Ainsi si vous spécifiez trois lignes et deux colonnes, la disposition ressemblera à ceci :

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

Remarquez que l'origine du repère est en haut à gauche.

Pour placer un widget dans une case, on utilise :

$table->attach( $child, $left_attach, $right_attach, $top_attach, $bottom_attach,
    $xoptions, $yoptions, $xpadding, $ypadding );

Sur la gauche de l'appel de fonction, la table que vous avez créée et le premier argument est le widget que vous souhaitez placer dans la table.

Les arguments $right_attach et $left_attach déterminent où placer le widget et combien de cases utiliser. Si vous voulez un bouton dans la case droite du bas de notre table 2×2 et voulez remplir cette entrée uniquement, alors :

$left_attach   = 1;
$right_attach  = 2;
$top_attach    = 1;
$bottom_attach = 2;

Maintenant si vous voulez qu'un widget occupe toute la ligne supérieure de notre table, vous devrez définir :

$left_attach   = 0;
$right_attach  = 2;
$top_attach    = 0;
$bottom_attach = 1;

$xoptions et $yoptions servent à spécifier les options de rangements et peuvent être combinées pour permettre multiples options.

Ces options sont :

• 'fill' si la case est plus grande que le widget et que 'fill' est spécifié, le widget s'étendra pour remplir tout l'espace vide ;
• 'shrink' : si on a alloué moins d'espace que requis pour le widget (habituellement quand l'utilisateur redimensionne la fenêtre) alors le widget devrait normalement dépasser du fond de la fenêtre et ne plus être visible. Si 'shrink' est spécifié, les widgets seront réduits avec la table ;
• 'expand' obligera la table à occuper tout l'espace restant dans la fenêtre.

Si vous souhaitez spécifier une de ces options, vous l'encadrez entre apostrophes comme ceci : 'option'. Mais si vous voulez combiner ces options, vous devrez les placer dans une liste anonyme comme ceci :

['option1', 'option2']

padding comme pour les boites, crée une zone claire autour du widget en pixel.

Une variation de attach() est attach_defaults() qui permet de vous dispenser des arguments $xoptions, $yoptions, $xpadding et $ypadding. Les valeurs par défaut de $xoptions et $yoptions sont ['fill', 'expand'] et celles de $xpadding et $ypadding sont initialisées à 0.

Nous avons aussi les fonctions set_row_spacing() et set_col_spacing() qui placent des espaces entre les lignes (et les colonnes), ou entre certaines lignes et certaines colonnes.

$table->set_row_spacing($row, $spacing);
$table->set_col_spacing($column, $spacing);

Notez que pour les colonnes, l'espace est placé à la droite de la colonne et pour les lignes, l'espace est placé dessous.

Vous pouvez aussi déclarer un espace consistant pour toutes les colonnes et les lignes avec :

$table->set_row_spacings($spacing);
$table->set_col_spacings($spacing);

Notez qu'avec ces appels, la dernière ligne et la dernière colonne ne reçoivent pas d'espace.

Si vous voulez redimensionner une table après l'avoir créée, vous pouvez utiliser :

$table->resize($rows, $columns);

Si vous voulez changer la valeur de la propriété homogeneous sur une table existante, vous pouvez utiliser :

$table->set_homogeneous($homogeneous);

L'argument $homogeneous est une valeur vraie ou fausse.

Ici, nous créons une fenêtre avec 3 boutons dans une table 2×2. Les deux premiers sont placés dans la ligne du haut. Un troisième, le bouton « quitter » est placé dans la ligne inférieure, occupant les deux colonnes. Cela doit ressembler à :

#!/usr/bin/Perl -w
use Gtk2 '-init';
use constant TRUE  => 1;
use constant FALSE => 0;

# Création de la fenêtre
my $window = Gtk2::Window->new('toplevel');
$window->signal_connect( 'delete event', sub { Gtk2->main_quit; } );
$window->set_title('Table');
$window->set_border_width(20);

# Création de la table
my $table = Gtk2::Table->new( 2, 2, TRUE );
$window->add($table);

# Création du premier bouton
$button1 = Gtk2::Button->new('bouton 1');
$button1->signal_connect( 'clicked', \&ButtonClicked, 'bouton 1' );

# Insère le bouton 1 dans la case en haut à gauche de la table
$table->attach_defaults( $button1, 0, 1, 0, 1 );
$button1->show();

# Création d' un second bouton
my $button2 = Gtk2::Button->new('bouton 2');
$button2->signal_connect( 'clicked', \&ButtonClicked, 'bouton 2' );

# Insère le bouton2 dans la case en haut à droite de la table
$table->attach_defaults( $button2, 1, 2, 0, 1 );
$button2->show();

# Crée le bouton 'Quit'
my $button3 = Gtk2::Button->new('Quitter');
$button3->signal_connect( 'clicked', sub { Gtk2->main_quit; } );

# Insère le bouton''quit'' dans les deux cases du bas
$table->attach_defaults( $button3, 0, 2, 1, 2 );

# Montre les divers éléments
$button1->show();
$button2->show();
$button3->show();
$table->show();
$window->show();

# On lance la boucle principale
Gtk2->main;
### onction de rappel
sub ButtonClicked {
    my ( $button, $text ) = @_;
    print("Vous avez pressé le $text \n");
}

$window->set_title($title);

$title contient le nom de la fenêtre.

Chaque fenêtre peut avoir un widget qui a « le focus », c'est-à-dire que tous les évènements clavier seront redirigés vers ce widget. En général, le widget qui a le focus est entouré d'un mince cadre noir. On peut changer le widget qui a le focus en appuyant sur la touche tab.

$window->set_focus($widget);

Les widgets qui ont le focus peuvent être activés en pressant sur la barre d'espace.

Le widget par défaut pour une fenêtre peut être déclaré par :

$window->set_default($widget);

Le widget par défaut peut être activé par la touche entrée.

L'attitude de la fenêtre détermine comment elle s'accommode des requêtes de redimensionnement.

$window->set_policy($allow_shrink, $allow_grow, $auto_shrink);

L'argument $allow_shrink est une valeur vraie ou fausse déterminant si l'utilisateur peut réduire une fenêtre en deçà de la taille requise.

L'argument $allow_grow est une valeur vraie ou fausse qui détermine si l'utilisateur peut agrandir la fenêtre au-delà de la taille requise.

L'argument $auto_shrink est une valeur vraie ou fausse spécifiant la fenêtre revient automatiquement à la taille précédente le changement si c'est une demande plus grande.

# la fenêtre est redimensionnable par l'utilisateur
$window->set_policy( FALSE, TRUE, FALSE );

# la taille de la fenêtre est contrôlée par le programme
$window->set_policy( FALSE, FALSE, TRUE );

Une fenêtre modale attire l'attention sur elle-même et reste au premier plan de telle sorte que l'utilisateur ne peut utiliser aucune autre fenêtre jusqu'à sa disparition. Les seuls évènements que l'application tolère sont ceux qui concernent la fenêtre modale. Les fenêtres sans mode ne gèlent pas le reste de l'application. Les fenêtres modales servent habituellement de boites de dialogues. Pour déclarer une fenêtre modale :

$window->set_modal($modal);

$modal est une valeur vraie ou fausse.

Vous pouvez déclarer la taille par défaut :

$window->set_default_size($width, $height);

Ou $width est la largeur et $height la hauteur de la fenêtre en pixels.

La position de la fenêtre peut être définie par :

$window->set_position($position);

Les différentes possibilités pour l'argument $position sont :

• 'none' aucune influence sur le placement. Le window manager du système place la fenêtre où il veut. C'est la valeur par défaut ;
• 'center' la fenêtre sera placée au centre de l'écran ;
• 'mouse' la fenêtre sera placée à l'endroit où se trouve la souris.

VI-A-1. Créer un bouton▲

$button = Gtk2::Button->new();
$button = Gtk2::Button->new($label);
$button = Gtk2::Button->new_with_label($label);
$button = Gtk2::Button->new_with_mnemonic($label);
$button = Gtk2::Button->new_from_stock($id);

$button->child->set("new label");

VI-A-2. Les signaux des boutons▲

VI-A-3. Styles de relief▲

$button->set_relief($relief_style);
$button->get_relief();

VI-A-4. Exemple▲

#!/usr/bin/Perl -w
use Gtk2 '-init';
use constant TRUE  => 1;
use constant FALSE => 0;

# Nombre de clics sur le bouton
my $numclicked = 0;

# Création de la fenêtre
my $window = Gtk2::Window->new("toplevel");
$window->signal_connect( "delete event", sub { Gtk2->main_quit; } );
$window->set_border_width(15);

# Création du bouton avec un texte qui est en réalité
# un label anonyme.
my $button = Gtk2::Button->new("Texte initial");
$button->signal_connect( "clicked", \&ClickedButtonEvent );
$window->add($button);
$button->show();

# montre la fenêtre
$window->show();

# boucle d'évènement Gtk2
Gtk2->main;
### Routines
# fonction appelée quand le bouton est cliqué
sub ClickedButtonEvent {
    if ( $numclicked == 0 ) {

        # Pour avoir accès au label contenu dans le bouton,
        # on doit appeler la méthode child héritée de GtkBin
        # qui renvoie le widget contenu, ici un label.
        $button->child->set_text("Texte changé ! !");
        $numclicked++;
    }
    elsif ( $numclicked == 1 ) {

        # Au second clic, on ôte le bouton présent. On en recrée
        # un que l'on peut activer grâce à la combinaison de touches
        # Alt + Q
        $window->remove($button);
        $button = Gtk2::Button->new_with_mnemonic("Appuyer sur Alt+\ Q");
        $button->signal_connect( "clicked", \&ClickedButtonEvent );
        $button->show();
        $window->add($button);
        $numclicked++;
    }
    elsif ( $numclicked == 2 ) {

        # On recommence la manipulation précédente sauf que l'on crée
        # un bouton Fermer standard ! !
        $window->remove($button);
        $button = Gtk2::Button->new_from_stock('gtk-close');
        $button->signal_connect( "clicked", \&ClickedButtonEvent );
        $button->show();
        $window->add($button);
        $numclicked++;
    }
    else {
        Gtk2->main_quit;
    }
}

Les boutons toggle sont dérivés des boutons normaux et sont très similaires sauf qu'ils n'ont que deux états possibles et qui change à l'aide d'un clic. Ils peuvent être remontés et quand vous cliquez, ils redescendent. Vous recliquez et ils remontent.

Les boutons toggle servent de base aux cases à cocher et aux boutons radio, au point que ces derniers héritent de beaucoup des appels utilisés pour les boutons toggle. Nous vous indiquerons lesquels quand nous les rencontrerons.

VI-B-1. Créer un bouton toggle▲

$button = Gtk2::ToggleButton->new();
$button = Gtk2::ToggleButton->new_with_label($label);
$button = Gtk2::ToggleButton->new_with_mnemonic($label);

sub toggle_button_callback {
    $togglebutton = $_[0];
    if ( $togglebutton->get_active ) {
        # Si le contrôle arrive là, le bouton est baissé
    }
    else {
        # Si le contrôle arrive là, le bouton est levé
    }
}

VI-B-2. Changer l'état du bouton▲

$togglebutton->set_active($state);

$togglebutton->get_active();

$togglebutton->toggled();

$bouton->set_inconsistent($setting);

$bouton->get_inconsistent();

VI-B-3. Exemple▲

 

Sélectionnez

# !/usr/bin/Perl -w

use Gtk2 '-init';
use constant TRUE  => 1;
use constant FALSE => 0;

my $window = Gtk2::Window->new("toplevel");
$window->signal_connect( "delete event", sub { Gtk2->main_quit; } );
$window->set_title("Les Interrupteurs");
$window->set_border_width(0);

my $box1 = Gtk2::VBox->new( FALSE, 0 );
$box1->show();
$window->add($box1);

# On crée le bouton toggle
my $button1 = Gtk2::ToggleButton->new("Etat relâché - Aspect normal");
$box1->pack_start( $button1, FALSE, FALSE, 0 );
$button1->signal_connect( "toggled", \&OnToggled );
$button1->show();

# On crée un bouton Etat
my $button2 = Gtk2::Button->new_with_label("Changer l'état");
$box1->pack_start( $button2, TRUE, TRUE, 0 );
$button2->signal_connect( "clicked", \&OnEtatClicked, $button1 );
$button2->show();

# On crée un bouton Aspect
my $button3 = Gtk2::Button->new_with_label("Changer l'aspect");
$box1->pack_start( $button3, TRUE, TRUE, 0 );
$button3->signal_connect( "clicked", \&OnAspectClicked, $button1 );
$button3->show();

$window->show();
Gtk2->main;

sub OnEtatClicked {
    my ( $widget, $button ) = @_;

    # On récupère l'état du bouton puis on le modifie
    my $etat = $button->get_active();
    $button->set_active( $etat, TRUE );
}

sub OnAspectClicked {
    my ( $widget, $button ) = @_;

    # On récupère l'aspect du bouton puis on le modifie
    my $binconsistent = $button->get_inconsistent();
    $button->set_inconsistent( $binconsistent, TRUE );

    # On émet le signal toggled pour changer le label du bouton
    $button->toggled();
}

sub OnToggled {
    my ($widget)      = @_;
    my $binconsistent = $widget->get_inconsistent();
    my $etat          = $widget->get_active();

    # On change le texte du label
    my $label =
      sprintf( "Etat : %s - Aspect : %s", $etat ? "enfoncé" : "relâché", $binconsistent ? "modifié" : "normal" );
    $widget->set_label($label);
}

Les cases à cocher héritent de beaucoup de propriétés et de fonctions des boutons toggle, mais ils ont une allure différente. Plutôt que d'être des boutons avec du texte à l'intérieur, ce sont des petites cases avec le texte à leur droite. Elles sont souvent utilisées pour choisir des options oui ou non dans une application.

Les deux fonctions de création sont les mêmes que pour un bouton normal.

$button = Gtk2::CheckButton->new();
$button = Gtk2::CheckButton->new($label);

Passer une chaine en argument crée une case à cocher avec un label à son côté. Le contrôle de l'état de la case se fait de la même manière que pour le bouton toggle.

Nous passons maintenant au widget GtkRadioButton qui se différencie des autres boutons par la possibilité d'en grouper plusieurs. De ce fait, lors que par exemple nous avons un groupe de trois boutons, il n'y en a qu'un seul qui peut être actif. On pourrait très bien faire cela avec le widget GtkCheckButton, mais cela serait beaucoup plus long à programmer. Dans la hiérarchie des widgets, GtkRadioButton dérive de GtkCheckButton.

VI-D-1. Création d'un groupe de radio.▲

$button = Gtk2::RadioButton->new($group,$label);
$button = Gtk2::RadioButton->new_with_mnemonic($group,$label);
$button = Gtk2::RadioButton->new_with_label_from_widget($button,$label);

$group = $button->get_group();

VI-D-2. Exemple▲

L'exemple suivant crée un groupe de trois boutons radio et affiche celui qui est actif quand on clique sur le bouton Valider.

 

Sélectionnez

# !/usr/bin/Perl -w

use Gtk2 '-init' ;

use constant TRUE => 1 ;
use constant FALSE => 0 ;

my $window = Gtk2::Window->new("toplevel") ;
$window->signal_connect("delete event" , sub { Gtk2->main_quit ; }) ;
$window->set_title("Radio Buttons") ;
$window->set_border_width(0) ;

my $box1 = Gtk2::VBox->new(FALSE, 0) ;
$box1->show() ;

my $box2 = Gtk2::VBox->new(FALSE, 10) ;
$box2->set_border_width(10) ;
$box1->pack_start($box2, FALSE, FALSE, 0) ;
$box2->show() ;
$window->add($box1) ;

# On crée un premier bouton radio que l'on place
# dans la boite.
my $button1 = Gtk2::RadioButton->new(undef, "bouton 1") ;
$box2->pack_start($button1, FALSE, FALSE, 0) ;
$button1->show() ;

# On récupère le groupe auquel appartient le premier bouton.
my $group = $button1->get_group() ;

# On crée un autre bouton radio que l'on rattache au groupe.
my $button2 = Gtk2::RadioButton->new_with_mnemonic($group, "bouton 2") ;

# On veut que ce bouton soit le bouton actif par défaut.
$button2->set_active(TRUE) ;
$box2->pack_start($button2, TRUE, TRUE, 0) ;
$button2->show() ;

# Même chose, mais sans passer par la variable $groupe.
my $button3 = Gtk2::RadioButton->new_with_label_from_widget($button1,"bouton 3") ;
$box2->pack_start($button3, TRUE, TRUE, 0) ;
$button3->show() ;

# Un séparateur pour l'esthétique
my $separator = Gtk2::HSeparator->new() ;
$box1->pack_start($separator, FALSE, FALSE, 0) ;
$separator->show() ;

## Le bouton valider qui lance une routine dont l'objectif
# est de nous indiquer lequel des boutons est actif.
my $button_close = Gtk2::Button->new_from_stock('gtk-ok') ;
$button_close->signal_connect("clicked" ,\&valider,$button1) ;
$box1->pack_start($button_close, TRUE, TRUE, 0) ;
$button_close->can_default(TRUE) ;
$button_close->grab_default() ;
$button_close->show() ;
$window->show() ;

Gtk2->main ;

sub valider{
    my ($widget,$button)=@_ ;

    # On récupère la référence du groupe auquel appartient le bouton
    my $group = $button->get_group() ;
    my $label ;
    # On parcourt le tableau des boutons et on affiche le bouton qui est actif.
    my $but ;
    foreach $but (@$group) {
        if ($but->get_active) {
            # On récupère le label du bouton actif
            $label = $but->get_label() ;
        }
    }
    # On affiche le tout dans une petite fenêtre de dialogue. Il faut tout d'abord
    # remonter jusqu'à la fenêtre mère.
    my $window = $widget->get_toplevel() ;
    
    # On peut alors créer notre fenêtre de dialogue. Nous verrons son fonctionnement plus tard.
    my $dialog = Gtk2::MessageDialog->new ($window,'modal' ,'info' ,'ok' , sprintf "Le %s est actif !" ,$label) ;
    $dialog->run ;
    $dialog->destroy ;
}

Dans toute cette section, nous verrons les fonctions qui existaient déjà dans GtkPerl, puis dans la section suivante, nous découvrirons les apports de Pango.

Les labels sont très utilisés avec GTK et sont relativement simples. Les labels n'émettent aucun signal puisqu'ils ne sont pas associés à une fenêtre X. Si vous avez besoin d'attraper des signaux, placez-les dans une boite à évènement ou dans un bouton.

Pour créer un nouveau label, utilisez :

$label = Gtk2::Label->new ($string);
$label = Gtk2::Label->new_with_mnemonic ($string);

Le seul argument est la chaine que vous voulez afficher.

Pour changer le texte du label après sa création, utilisez la fonction :

$label->set_text($string);

Encore une fois, l'argument est la nouvelle chaine.

L'espace utilisé pour la nouvelle chaine sera ajusté automatiquement si nécessaire. Vous pouvez produire des labels multilignes en plaçant des caractères de fin de ligne dans la chaine.

Pour retrouver la chaine courante, utilisez :

$label->get();

Le texte du label peut être justifié avec :

$label->set_justify($jtype);

Les valeurs de $jtype sont :

'left'
'right'
'center' (default)
'fill'

Le widget label est également capable de faire automatiquement les césures du texte en fin de ligne. Cela peut être activé par :

$label->set_line_wrap($wrap);

L'argument $wrap est une valeur vraie ou fausse.

Si vous voulez un label souligné, vous pouvez déclarer un patron pour le label :

$label->set_pattern($pattern);

L'argument pattern indique comment souligner le texte. Cela consiste en une chaine de caractère et d'espace. Le caractère indique les caractères du label à souligner. Par exemple , la chaine « _ _ _ _ _ _ » soulignera le premier, le troisième, le cinquième, le septième et le neuvième caractère. Notez toutefois qu'il ne faut pas confondre ce caractère de soulignement avec celui créé par la fonction new_with_mnemonic().

VII-A-1. Exemple▲

Voici un court exemple qui illustre ces fonctions. Il utilise le widget cadre pour mieux mettre en valeur les styles de labels. Vous pouvez l'ignorer pour le moment, car le widget cadre sera expliqué plus tard.

 

Sélectionnez

# !/usr/bin/Perl -w

use Gtk2 '-init' ;

use constant TRUE => 1 ;
use constant FALSE => 0 ;

use strict ;

my $window = Gtk2::Window->new("toplevel") ;
$window->signal_connect("destroy" , sub { Gtk2->main_quit ; }) ;
$window->set_title("Les labels") ;
$window->set_border_width(5) ;

my $hbox = Gtk2::HBox->new(FALSE, 5) ;
$window->add($hbox) ;

my $vbox1 = Gtk2::VBox->new(FALSE, 5) ;
$hbox->pack_start($vbox1, FALSE, FALSE, 0) ;

my $label1 = Gtk2::Label->new("Ceci est un label normal") ;
my $frame1 = Gtk2::Frame->new("Label normal") ;
$frame1->add($label1) ;
$vbox1->pack_start($frame1, FALSE, FALSE, 0) ;

my $label2 = Gtk2::Label->new("Ceci est un label multiligne.\n Seconde ligne\n"
  . "Troisième Line") ;
my $frame2 = Gtk2::Frame->new(" Label multiligne ") ;
$frame2->add($label2) ;
$vbox1->pack_start($frame2, FALSE, FALSE, 0) ;

my $label3 = Gtk2::Label->new("Ceci est un label justifié à gauche. \n"
  ."Multi-lignes\n"
  ."Troisième ligne") ;
$label3->set_justify('left') ;

my $frame3 = Gtk2::Frame->new("Label justifié à gauche") ;
$frame3->add($label3) ;
$vbox1->pack_start($frame3, FALSE, FALSE, 0) ;

my $label4 = Gtk2::Label->new("Ceci est un label justifié à droite.\n "
  . "Multi-lignes.\n"
  . "Troisième ligne.") ;
$label4->set_justify('right') ;
my $frame4 = Gtk2::Frame->new("Label justifié à droite") ;
$frame4->add($label4) ;
$vbox1->pack_start($frame4, FALSE, FALSE, 0) ;

my $vbox2 = Gtk2::VBox->new(FALSE, 5) ;
$hbox->pack_start($vbox2, FALSE, FALSE, 0) ;
my $frame5 = Gtk2::Frame->new("Label avec l'option line wrap") ;
my $label5 = Gtk2::Label->new("Ceci est un exemple de césure de ligne. "
  . "Cela ne devrait pas prendre la largeur totale "
  . "allouée mais fait passer les mots à la ligne "
  . "automatiquement. "
  . " Cela supporte correctement plusieurs "
  . "paragraphes et ajoute également "
  . "plusieurs espaces. ") ;
$label5->set_line_wrap(TRUE) ;
$frame5->add($label5) ;
$vbox2->pack_start($frame5, FALSE, FALSE, 0) ;

my $frame6 = Gtk2::Frame->new("Label avec l'opton line wrap et fill") ;
my $label6 = Gtk2::Label->new(" Ceci est un exemple de césure de ligne.L'option fill, "
  . "fait que le texte prend "
  . "toute la largeur disponible. "
  . "Voici une phrase qui le prouve. "
  . "Et en voici une autre. "
  . "Here comes the sun, do de do de do.\n"
  . " Ceci est un nouveau paragraphe\n"
  . " Un autre nouveau , plus long, meilleur. "
  . "On arrive à la fin, "
  . "malheureusement.") ;
$label6->set_justify('fill') ;
$label6->set_line_wrap(TRUE) ;
$frame6->add($label6) ;
$vbox2->pack_start($frame6, FALSE, FALSE, 0) ;

my $frame7 = Gtk2::Frame->new("Label souligné") ;
my $label7 = Gtk2::Label->new("Voici un label souligné !\n"
  . "Celui-là est souligné à la mode funky ") ;
$label7->set_justify('left') ;
$label7->set_pattern(" "
  . " ") ;
$frame7->add($label7) ;
$vbox2->pack_start($frame7, FALSE, FALSE, 0) ;

$window->show_all() ;

Gtk2->main ;

La gestion des caractères est, en C, l'œuvre de la bibliothèque Pango. En Perl, à quelques exceptions prêtes, nous n'avons pas à nous préoccuper de cette librairie, Gtk2-Perl fait le travail pour nous.

VII-B-1. Formatage de texte▲

VII-B-2. Définition du format▲

VII-B-3. Les balises rapides▲

$label->set_markup($texte_avec_balises);

VII-B-4. La balise <span>▲

Cette fois-ci, nous allons étudier la balise <span> en détail. Avec celle-ci, nous allons pouvoir changer la police de caractères, la couleur du texte et bien d'autres choses.

Cette balise s'utilise comme les précédentes si ce n'est qu'elle accepte des paramètres. La liste ci-dessous présente tous les paramètres et les effets sur le texte.

• font_family pour définir la police à utiliser. Si la valeur donnée à ce paramètre est incorrecte, la police par défaut (Sans Serif) sera utilisée ;
• face identique à font_family
• size pour définir la taille du texte (par défaut 10) ;
• style pour définir le style du texte. Trois valeurs possibles : normal, oblique, italic. Exemple : <span style='oblique'>Oblique</span> ;
• font_desc permet de combiner les paramètres précédents en un seul ;
• weight permet de définir l'épaisseur des lettres. Les valeurs peuvent être ultralight, light, normal, bold, utrabold, heavy ou encore une valeur numérique. (Vous remarquerez qu'il n'y a que peu ou pas de différence) ;
• variant pour définir si l'on veut du texte normal (normal) ou en petite majuscule smallcaps) ;
• stretch permet d'étirer le texte. La valeur de ce paramètre peut être : ultracondensed, extracondensed, condensed, semicondensed, normal, semiexpanded, expanded, extraexpanded, ultraexpanded ;
• foreground pour définir la couleur du texte. Il faut donner la valeur hexadécimale de la palette RVB ;
• background pour définir la couleur du fond. Il faut donner la valeur hexadécimale de la palette RVB ;
• underline pour souligner le texte ;
• rise pour déplacer le texte verticalement ;
• strikethrough pour barrer le texte, par exemple : <span strikethrough='true'>Striketrough = "true"</span> ;
• lang pour indiquer la langue du texte.

Tous ces paramètres peuvent être mis à l'intérieur d'une seule balise <span>.

 

Sélectionnez

# !/usr/bin/Perl -w

use strict ;
use Gtk2 '-init' ;

# Variables convenables pour vrai et faux
use constant TRUE => 1 ;
use constant FALSE => 0 ;

my $window = Gtk2::Window->new("toplevel") ;
$window->signal_connect("destroy" , sub { Gtk2->main_quit ; }) ;
$window->set_title("Les labels avec style") ;
$window->set_border_width(5) ;
$window->set_default_size(320 ,100) ;

my $vbox = Gtk2::VBox->new() ;
$window->add($vbox) ;
$vbox->show() ;

my $label1 = Gtk2::Label->new() ;
$label1->set_markup("<span face='Courier New'><b>Courier New 10 Gras</b></span>\n") ;

my $label2 = Gtk2::Label->new() ;
$label2->set_markup("<span font desc='Times New Roman italic 12' foreground='#0000FF'>Times New Roman
12 Italique</span>\n") ;

my $label3 = Gtk2::Label->new() ;
$label3->set_markup("<span font desc='Sans 16' foreground='#00FF00'><u>Sans 16 Souligné</u></span>") ;

$vbox->pack_start($label1, FALSE, FALSE, 0) ;
$vbox->pack_start($label2, FALSE, FALSE, 0) ;
$vbox->pack_start($label3, FALSE, FALSE, 0) ;
$label1->show() ;
$label2->show() ;
$label3->show() ;

$window->show() ;

Gtk2->main ;

GTK possède plusieurs widgets qui peuvent être ajustés visuellement par l'utilisateur à l'aide de la souris ou du clavier, comme le widget range. Il y a aussi quelques widgets qui mettent à disposition des portions ajustables pour une plus grande surface de données comme les widgets texte et viewport.

Évidemment, une application a besoin d'être capable de réagir aux changements que l'utilisateur. Une manière de le faire serait que chaque widget émette son propre type de signal quand son réglage change et même passe la nouvelle valeur au gestionnaire de signal, ou lui demande de regarder à l'intérieur des données du widget afin de s'informer de la valeur. Vous pouvez aussi vouloir connecter les réglages de plusieurs widgets ensemble afin que les réglages de l'un règlent les autres. L'exemple le plus simple de ce phénomène est de connecter une barre de défilement à une zone de texte ou à un « panning viewport ». Si chaque widget possède son propre moyen de déclarer ou de récupérer la valeur du réglage alors le programmeur doit écrire leurs propres gestionnaires de signal pour faire la traduction entre la sortie du signal d'un widget et l'entrée d'une autre fonction déclarant les réglages.

GTK résout ce problème en utilisant l'objet Adjustment qui n'est pas vraiment un widget, mais un moyen pour les widgets de stocker et de passer des informations de réglages sous une forme concise et flexible. L'usage le plus évident de l'ajustement est de stocker les paramètres de configuration et les valeurs des widgets « Range » comme les barres de défilement et les contrôles d'échelle. Quoi qu'il en soit, puisque les Adjustments sont dérivés de la classe Objet, ils possèdent des pouvoirs spéciaux supérieurs à ceux des structures de données normales. Plus important, ils peuvent émettre des signaux tout comme les widgets, et ces signaux peuvent être utilisés non seulement pour permettre à vos programmes de réagir aux entrées utilisateurs sur certains widgets réglables, mais également pour propager les valeurs des réglages de manière transparente entre les widgets réglables. Malheureusement, les réglages peuvent être difficiles à comprendre, c'est pourquoi il est possible que vous ne voyiez pas bien le rôle des réglages avant d'avoir vu les widgets qui les utilisent comme les barres de progression, les viewport, les barres de défilement.

VIII-A-1. Créer des Ajustements▲

Gtk2::Adjustment->new($value,$lower,$upper,$step_increment,$page_increment,$page_size);

VIII-A-2. Utiliser les ajustements : la manière facile▲

VIII-A-3. Les ajustements internes▲

get_adjustment->adjustment_name ;

value
lower
upper
step_increment
page_increment
page_size

$adjustment->set_value($value);

sub cb_rotation_image
{
    ($adjustment, $image)=@_;
    $image->rotation($adjustment->get_adjustment->value);
    ...
}

$adjustment->signal_connect("value_changed",\&cb_rotation_image,$image);

$adjustment->signal_emit("changed");

La catégorie des widgets Range inclut la barre de défilement et la moins commune glissière. Bien que ces deux widgets soient généralement utilisés dans des buts différents, ils sont presque similaires en fonction et en implémentation. Tous les widgets Range partagent un ensemble d'éléments graphiques, chacun possédant sa propre fenêtre X et recevant les évènements. Ils contiennent tous une glissière et un curseur (parfois appelé « thumbwheel » dans d'autres environnements GUI). Prendre le curseur avec le pointeur de la souris le promène le long de la glissière alors que cliquer dans la glissière avance le curseur en direction du lieu du clic, soit complètement soit d'une quantité fixée dépendant du bouton de la souris utilisé.

Comme mentionné précédemment, tous les widgets Range sont associés à un objet Adjustment à partir duquel ils calculent la longueur du curseur et sa position dans la glissière. Quand l'utilisateur manipule le curseur, le widget range changera la valeur de l'ajustement.

VIII-B-1. Les fonctions communes▲

$range->set_update_policy($policy);

$range->get_adjustment();
$range->set_adjustment($adjustment);

$adjustment->signal_emit ("changed");

Tous les widgets Range de GTK réagissent aux clics de souris plus ou moins de la même manière. Cliquer avec le bouton 1 dans la glissière fera que le page_increment de l'ajustement sera ajouté ou soustrait à sa value, et que le curseur sera bougé en conséquence. Cliquer sur le bouton 2 dans la glissière fera sauter le curseur jusqu'à l'endroit du clic. Cliquer sur l'une des flèches de la barre de défilement provoquera un changement de la valeur du réglage égal au step_increment. Cela peut prendre un certain temps à maîtriser, mais par défaut, les barres de défilement, tout comme les widgets échelles, peuvent être manipulés au clavier (état « focus ») en GTK. Si vous pensez que l'utilisateur sera dérouté, vous pouvez toujours rendre cette option indisponible en invalidant le flag « focus » de la barre de défilement.

$scrollbar->unset_flags('focus');

Les comportements claviers (qui ne sont bien sûr disponible que si le flag « focus » est actif) sont, pour des raisons évidentes, légèrement différents en fonction des widgets Range horizontaux et verticaux. Ils ne sont d'ailleurs pas tout à fait les mêmes selon qu'il s'agisse d'un widget échelle ou d'une barre de défilement, pour des raisons un peu moins évidentes (peut-être pour éviter la confusion entre les touches pour la barre horizontale et ceux pour la barre verticale dans les fenêtres défilables, qui, chacune, opèrent dans le même domaine).

Tous les widgets Range verticaux peuvent être modifiés à l'aide des flèches vers le haut et vers le bas du clavier, aussi bien qu'avec les touches Page up et Page down. Les flèches montent et descendent le curseur selon le step_increment alors que Page up et Page down le modifie selon le page_increment. L'utilisateur peut aussi déplacer le curseur tout en haut ou tout en bas de la glissière à l'aide du clavier. Avec le widget VScale, c'est fait avec les touches Home et End alors qu'avec VScrollbar c'est fait en tapant Control Page up et Control Page down.

Les flèches droite et gauche agissent comme on peut s'y attendre sur le widget Range en bougeant le curseur selon le step_increment. Les touches Home et End bougent le curseur au début ou à la fin de la glissière. Pour le HScale widget, bouger le curseur selon le page_increment se fait à l'aide des touches Control Right et Control Left alors que pour le HScrollbar c'est Control Home et Control End.

Cet exemple crée une fenêtre avec trois widgets Range, tous connectés au même réglage, et un couple de contrôle pour régler quelques-uns des paramètres mentionnés ci-dessus dans la section sur les réglages. Ainsi, vous pourrez voir comment ils affectent la manière dont ces widgets fonctionnent pour l'utilisateur.

#!/usr/bin/Perl -w

use strict ;

use Gtk2 '-init' ;

use constant TRUE => 1 ;
use constant FALSE => 0 ;

# Création standard de la fenêtre
my $window = Gtk2::Window->new("toplevel") ;
$window->set_title("Les ajustements, les glissières et les barres de défilement") ;
$window->signal_connect("destroy" , sub { Gtk2->main_quit ; }) ;

# Une première boite verticale
my $box1 = Gtk2::VBox->new(FALSE, 0) ;
$window->add($box1) ;
$box1->show() ;

# Une nouvelle boite horizontale
my $box2 = Gtk2::HBox->new(TRUE, 10) ;
$box2->set_border_width(10) ;
$box1->pack_start($box2, TRUE, TRUE, 0) ;
$box2->show() ;

# Création du ajustement avec les arguments
# value, lower, upper, step increment, page_increment, page_size
# Notez que la valeur de page_size fait seulement une différence pour
# les widgets scrollbar , et la plus haute valeur que nous obtiendrons est
# (upper - page_size).
my $adj1 = Gtk2::Adjustment->new(0.0 , 0.0 , 100.0 , 0.1 , 1.0 , 1.0) ;

# Une glissière verticale
my $vscale1 = Gtk2::VScale->new($adj1) ;
$box2->pack_start($vscale1, TRUE, TRUE, 0) ;
$vscale1->show() ;

# Une troisième boite verticale
my $box3 = Gtk2::VBox->new(FALSE, 10) ;
$box2->pack_start($box3, TRUE, TRUE, 0) ;
$box3->show() ;

# Réutilise le même ajustement
my $hscale1 = Gtk2::HScale->new($adj1) ;
$hscale1->set_size_request(200 , 100) ;
$box3->pack_start($hscale1, TRUE, TRUE, 0) ;
$hscale1->show() ;

# Réutilise encore le même ajustement pour une barre de défilement
my $scrollbar = Gtk2::HScrollBar->new($adj1) ;

# Notez que cela implique que les échelles seront mises à jour
# continuellement quand la barre de défilement est bougée
$scrollbar->set_update_policy('continuous') ;
$box3->pack_start($scrollbar, TRUE, TRUE, 0) ;
$scrollbar->show() ;

# Une nouvelle boite
my $box4 = Gtk2::HBox->new(FALSE, 10) ;
$box4->set_border_width(10) ;
$box1->pack_start($box4, TRUE, TRUE, 0) ;
$box4->show() ;

# Une case à cocher pour contrôler si la valeur des glissières
# est affichée ou non
my $button1 = Gtk2::CheckButton->new("Affichage de la valeur des widgets range") ;
$button1->set_active(TRUE) ;
$button1->signal_connect("toggled" , \&cb_draw_value) ;
$box4->pack_start($button1, TRUE, TRUE, 0) ;
$button1->show() ;

# Une nouvelle boite
my $box5 = Gtk2::HBox->new(FALSE, 10) ;
$box5->set_border_width(10) ;
# Une option du menu pour changer la position de la valeur.
my $label = Gtk2::Label->new("Position de la valeur numérique :") ;
$box5->pack_start($label, FALSE, FALSE, 0) ;
$label->show() ;
# Un menu à option que nous documenterons plus tard
my $opt = Gtk2::OptionMenu->new() ;
my $menu = Gtk2::Menu->new() ;
# Premier élément du menu
my $item = make_menu_item("en haut" , \&cb_pos_menu_select, 'top') ;
$menu->append($item) ;
# Second élément du menu
$item = make_menu_item("en bas" , \&cb_pos_menu_select, 'bottom') ;
$menu->append($item) ;
# Troisième élément du menu
$item = make_menu_item("à gauche" , \&cb_pos_menu_select, 'left') ;
$menu->append($item) ;
# Quatrième élément du menu
$item = make_menu_item("à droite" , \&cb_pos_menu_select, 'right') ;
$menu->append($item) ;
# On place de tout dans le menu puis dans la boite
$opt->set_menu($menu) ;
$box5->pack_start($opt, TRUE, TRUE, 0) ;
$opt->show() ;

$box1->pack_start($box5, TRUE, TRUE, 0) ;
$box5->show() ;

# Une nouvelle boite
my $box6 = Gtk2::HBox->new(FALSE, 10) ;
$box6->set_border_width(10) ;
# Une autre option du menu, cette fois-ci pour changer la politique
# de mise à jour des widgets échelles
my $label2 = Gtk2::Label->new("Option de mise à jour :") ;
$box6->pack_start($label2, FALSE, FALSE, 0) ;
$label2->show() ;
# Encore un menu à option
my $opt2 = Gtk2::OptionMenu->new() ;
my $menu2 = Gtk2::Menu->new() ;
# Premier élément du menu
$item = make_menu_item ("Continu" , \&cb_update_menu_select, 'continuous') ;
$menu2->append($item) ;
# Second élément du menu
$item = make_menu_item ("Discontinu" , \&cb_update_menu_select, 'discontinuous') ;
$menu2->append($item) ;
# Troisième élément du menu
$item = make_menu_item ("Retardé" , \&cb_update_menu_select, 'delayed') ;
$menu2->append($item) ;
# On place le tout dans le menu puis dans la boite
$opt2->set_menu($menu2) ;
$box6->pack_start($opt2, TRUE, TRUE, 0) ;
$opt2->show() ;
$box1->pack_start($box6, TRUE, TRUE, 0) ;
$box6->show() ;

# Une nouvelle boite
my $box7 = Gtk2::HBox->new(FALSE, 10) ;
$box7->set_border_width(10) ;

# Un widget HScale pour ajuster le nombre de digits
# sur les exemple d'échelle.
my $label3 = Gtk2::Label->new("Nombre de décimales :") ;
$box7->pack_start($label3, FALSE, FALSE, 0) ;
$label3->show() ;

# On crée un ajustement pour le nombre de décimales
my $adj2 = Gtk2::Adjustment->new(1.0 , 0.0 , 5.0 , 1.0 , 1.0 , 0.0) ;
$adj2->signal_connect("value changed" , \&cb_digits_scale) ;
# puis on l'utilise avec le widget HScale
my $scale2 = Gtk2::HScale->new($adj2) ;
$scale2->set_digits(0) ;
$box7->pack_start($scale2, TRUE, TRUE, 0) ;
$scale2->show() ;
$box1->pack_start($box7, TRUE, TRUE, 0) ;
$box7->show() ;

# Une nouvelle boite horizontale
my $box8 = Gtk2::HBox->new(FALSE, 10) ;
$box8->set_border_width(10) ;

# Et un dernier widget HScale pour ajuster la taille du curseur de la scrollbar
my $label4 = Gtk2::Label->new("Taille du curseur de la barre de défilement :") ;
$box8->pack_start($label4, FALSE, FALSE, 0) ;
$label4->show() ;

# Un troisième objet ajustement pour la taille du curseur
my $adj3 = Gtk2::Adjustment->new(1.0 , 1.0 , 100.0 , 1.0 , 1.0 , 0.0) ;
$adj3->signal_connect("value changed" , \&cb_page_size, $adj1) ;
# puis on l'utilise avec le widget HScale
my $scale3 = Gtk2::HScale->new($adj3) ;
$scale3->set_digits(0) ;
$box8->pack_start($scale3, TRUE, TRUE, 0) ;
$scale3->show() ;
$box1->pack_start($box8, TRUE, TRUE, 0) ;
$box8->show() ;

my $separator = Gtk2::HSeparator->new() ;

$box1->pack_start($separator, FALSE, TRUE, 0) ;
$separator->show() ;

# Le bouton pour quitter
my $button = Gtk2::Button->new_from_stock("gtk-quit") ;
$button->signal_connect("clicked" , sub { Gtk2->main_quit ; }) ;
$box1->pack_start($button, TRUE, TRUE, 0) ;
$button->can_default(TRUE) ;
$button->grab_default() ;
$button->show() ;
$window->show() ;


Gtk2->main ;

### Fonctions de rappels
sub cb_pos_menu_select
{
    my ($item, $pos) = @_ ;
    # Déclare le valeur de la position pour chaque widget scale
    $hscale1->set_value_pos($pos) ;
    $vscale1->set_value_pos($pos) ;
}

sub cb_update_menu_select
{
    my ($item, $policy) = @_ ;
    # Déclare la politique de mise à jour pour chaque widget scale
    $hscale1->set_update_policy($policy) ;
    $vscale1->set_update_policy($policy) ;
}

sub cb_digits_scale
{
    my ($adj) = @_ ;
    # Déclare le nombre de décimales pour adj->value
    $hscale1->set_digits($adj->value) ;
    $vscale1->set_digits($adj->value) ;
}

sub cb_page_size
{
    my ($get, $set) = @_ ;

    # Déclare le page_size and page_increment size pour l'ajustement
    # à la valeur spéficiée par la "Page Size" de l'échelle
    $set->page_size($get->value) ;
    $set->page_increment($get->value) ;

    # émet maintenant le signal "changed" pour reconfigurer tous les widgets
    # qui sont liés à ce réglage
    $set->signal_emit("changed") ;
}

sub cb_draw_value
{
    my ($button) = @_ ;
    # branche la valeur de l'affichage, débranche les widgets échelle
    # selon l'état de la case à cocher
    $hscale1->set_draw_value($button->get_active) ;
    $vscale1->set_draw_value($button->get_active) ;
}

# Fonctions pratiques
sub make_menu_item
{
    my ($name, $callback, $data) = @_ ;
    my $item ;
    $item = Gtk2::MenuItem->new($name) ;
    $item->signal_connect("activate" , $callback, $data) ;
    $item->show() ;
    return $item ;
}

sub scale_set_default_values
{
    my ($scale) = @_ ;
    $scale->set_update_policy('continuous') ;
    $scale->set_digits(1) ;
    $scale->set_value_pos('top') ;
    $scale->set_draw_value(TRUE) ;
}

Pour construire un tel menu, nous allons utiliser pas moins de trois widgets différents qui serviront tous à différentes étapes de la création. Ces widgets sont MenuBar, Menu, MenuItem.

IX-A-1. Les éléments d'un menu.▲

Dans un premier temps, le plus simple est de voir comment seront disposés ces trois widgets dans notre futur menu.

Nous avons tout d'abord le widget MenuBar (en rouge) qui est l'élément principal de notre menu. Il contient des éléments de type GtkMenuItem (en bleu) qui peuvent ouvrir des éléments GtkMenu (en vert) contenant aussi des GtkMenuItem.

Du point de vue du fonctionnement, les éléments GtkMenuItem peuvent soit ouvrir un sous-menu (élément Gtk-Menu) soit exécuter l'action qui lui est associée par l'intermédiaire d'une fonction de rappel. Il ne reste maintenant plus qu'à créer notre menu.

IX-A-2. Création d'un menu▲

IX-A-3. Création de l'élément MenuBar▲

$menubar = Gtk2::MenuBar->new ();

IX-A-4. Création d'un élément Menu qui sera un menu▲

$menu = Gtk2::Menu->new ();

IX-A-5. Création des éléments MenuItem à insérer dans le menu▲

$menuitem = Gtk2::MenuItem->new ();
$menuitem = Gtk2::MenuItem->new_with_label ($label);
$menuitem = Gtk2::MenuItem->new_with_mnemonic ($label);

$menu->append($menuitem);
$menu->prepend($menuitem);

IX-A-6. Création de l'élément MenuItem qui ira dans l'élément MenuBar▲

IX-A-7. Association de cet élément avec le menu créé précédemment▲

$menuitem_avec_sous_menu->set_submenu($menu);

IX-A-8. Ajout de l'élément MenuItem dans la barre MenuBar▲

Notre exemple comportera deux menus. Le premier « Fichier », proposera des fonctions inactives (« Nouveau », « Ouvrir », « Enregistrer », « Fermer ») et une fonction active (« Quitter »), alors que le second «  ? » proposera la fonction « À propos de… ».

# !/usr/bin/Perl -w

use strict ;
use Gtk2 '-init' ;
use constant TRUE => 1 ;
use constant FALSE => 0 ;

# Création de la fenêtre
my $window = Gtk2::Window->new("toplevel") ;
$window->set_title ("Les menus (1)") ;
$window->signal_connect (destroy => sub { Gtk2->main_quit }) ;
$window->set_default_size(320 ,200) ;

# Création de la GtkVBox
my $vbox = Gtk2::VBox->new(FALSE, 0) ;
$window->add($vbox) ;

###### réation du menu #####

### Étape 1
my $menubar = Gtk2::MenuBar->new() ;

### Premier sous-menu
### Étape 2
my $menu1= Gtk2::Menu->new() ;

### Étape 3
my $menuitem1 = Gtk2::MenuItem->new_with_label("Nouveau") ;
$menu1->append($menuitem1) ;

my $menuitem2 = Gtk2::MenuItem->new_with_label("Ouvrir") ;
$menu1->append($menuitem2) ;

my $menuitem3 = Gtk2::MenuItem->new_with_label("Enregistrer") ;
$menu1->append($menuitem3) ;

my $menuitem4 = Gtk2::MenuItem->new_with_label("Fermer") ;
$menu1->append($menuitem4) ;

my $menuitem5 = Gtk2::MenuItem->new_with_label("Quitter") ;
$menu1->append($menuitem5) ;
$menuitem5->signal_connect("activate" ,\&on_quitter,$window) ;

### Étape 4
my $menuitem6 = Gtk2::MenuItem->new_with_label("Fichier") ;

### Étape 5
$menuitem6->set_submenu($menu1) ;

### Étape 6
$menubar->append($menuitem6) ;

### Second sous-menu **/
### Étape 2
my $menu2 = Gtk2::Menu->new() ;

### Étape 3
my $menuitem7 = Gtk2::MenuItem->new_with_label("À propos de ...") ;
$menu2->append($menuitem7) ;
$menuitem7->signal_connect("activate" ,\&on_about,$window) ;

### Étape 4
my $menuitem8 = Gtk2::MenuItem->new_with_label(" ?") ;

### Étape 5
$menuitem8->set_submenu($menu2) ;

### Étape 6
$menubar->append($menuitem8) ;

### Ajout du menu a la fenêtre
$vbox->pack_start($menubar,FALSE,FALSE,0) ;

$window->show_all() ;
Gtk2->main() ;

### Les fonctions de rappels
### Ici on demande une confirmation pour quitter l'application
sub on_quitter{
    my ($widget,$window) = @_ ;
    my $dialog = Gtk2::MessageDialog->new ($window,
      [qw/modal destroy-with-parent/],
      'question' ,
      'yes no' ,
      "Voulez-vous vraiment \n quitter le programme ?") ;
    my $reponse = $dialog->run ;
    if ($reponse eq "yes") {
        Gtk2->main_quit ;
    }
    else {
        $dialog->destroy() ;
    }
}

sub on_about {
    my ($widget,$window) = @_ ;
    
    my $dialog = Gtk2::MessageDialog->new ($window,
      [qw/modal destroy-with-parent/],
      'info' ,
      'ok' ,
      "Gtk2 Perl tutoriel") ;
    $dialog->run ;
    $dialog->destroy() ;
}

En plus des MenuItem, GTK+ offre cinq éléments de menu additionnels prêts à l'emploi : ImageMenuItem, Radio-MenuItem, CheckMenuItem, SeparatorMenuItem et TearoffMenuItem. Bien entendu toutes les fonctions s'appliquant sur des MenuItems s'appliquent aussi à ces items (héritage oblige).

• ImageMenuItem est un widget qui permet de créer une entrée de menu textuelle avec une icône juste devant ;
• RadioMenuItem est un widget qui fonctionne selon les mêmes principes que les boutons radio ;
• CheckMenuItem est un widget à trois états que l'on peut cocher ;
• SeparatorMenuItem est un widget qui sert simplement à séparer des parties de menu grâce à une ligne horizontale. Leur but est uniquement décoratif ;
• TearoffMenuItem est un widget qui permet de détacher le menu de sa barre et d'en faire une fenêtre à part entière.

IX-C-1. Les ImageMenuItems▲

$menuitem = Gtk2::ImageMenuItem->new();
$menuitem = Gtk2::ImageMenuItem->new_from_stock($stock_id,$accel);
$menuitem = Gtk2::ImageMenuItem->new_with_label($label);
$menuitem = Gtk2::ImageMenuItem->new_with_mnemonic($label);

$menuitem->set_image($image);

$image = $menuitem->get_image();

IX-C-2. Les CheckMenuItems▲

$menuitem = Gtk2::CheckMenuItem->new();
$menuitem = Gtk2::CheckMenuItem->new_with_label($label);
$menuitem = Gtk2::CheckMenuItem->new_with_mnemonic($label);

$menuitem->set_active($is_active);
$menuitem->set_inconsistent($setting);
$menuitem->toggled();

$etat = $menuitem->get_active();
$etat = $menuitem->get_inconsistent();

IX-C-3. Les RadioMenuItems▲

$menuitem = Gtk2::RadioMenuItem->new($group);
$menuitem = Gtk2::RadioMenuItem->new_with_label($group,$label);
$menuitem = Gtk2::RadioMenuItem->new_with_mnemonic($group,$label);

$menuitem->get_group();

$menuitem->set_group($group);

IX-C-4. Les SeparatorMenuItems▲

$menuitem = Gtk2::SeparatorMenuItem->new();

IX-C-5. Les TearoffMenuItems▲

$menuitem = Gtk2::TearoffMenuItem->new();

$etat = $menu->get_tearoff_state();

IX-C-6. Programme exemple▲

Nous avons repris l'exemple précédent en modifiant le menu pour y mettre nos nouveaux items et en y ajoutant trois labels pour indiquer l'état des différents items. Il y a aussi trois fonctions de rappels supplémentaires pour la mise à jour de nos labels.

 

Sélectionnez

# !/usr/bin/Perl -w

use strict ;
use Gtk2 '-init' ;
use constant TRUE => 1 ;
use constant FALSE => 0 ;

# Création de la fenêtre
my $window = Gtk2::Window->new("toplevel") ;
$window->set_title ("Les menus (2)") ;
$window->signal_connect (destroy => sub { Gtk2->main_quit }) ;
$window->set_default_size(320 ,200) ;

# Création de la GtkVBox
my $vbox = Gtk2::VBox->new(FALSE, 0) ;
$window->add($vbox) ;

my $accel = Gtk2::AccelGroup->new() ;

###### réation du menu #####
### Étape 1
my $menubar = Gtk2::MenuBar->new() ;
### Premier sous-menu
### Étape 2
my $menu1= Gtk2::Menu->new() ;
### Étape 3
my $menuitem1 = Gtk2::TearoffMenuItem->new() ;
$menu1->append($menuitem1) ;
$menuitem1->signal_connect("activate" ,\&on_tearoff,$menu1) ;

my $menuitem2 = Gtk2::ImageMenuItem->new_from_stock("gtk-new" ,$accel) ;
$menu1->append($menuitem2) ;

my $menuitem3 = Gtk2::ImageMenuItem->new_from_stock("gtk-open" ,$accel) ;
$menu1->append($menuitem3) ;

my $menuitem4 = Gtk2::ImageMenuItem->new_from_stock("gtk-save" ,$accel) ;
$menu1->append($menuitem4) ;

my $menuitem5 = Gtk2::ImageMenuItem->new_from_stock("gtk-close" ,$accel) ;
$menu1->append($menuitem5) ;

my $menuitem6 = Gtk2::SeparatorMenuItem->new() ;
$menu1->append($menuitem6) ;

my $menuitem7 = Gtk2::RadioMenuItem->new_with_label(undef,"Radio1") ;
$menu1->append($menuitem7) ;

my $group = $menuitem7->get_group() ;

### Il est inutile ici d'utiliser le signal "toggled"
$menuitem7->signal_connect("activate" ,\&on_radio) ;

##### Les boutons radio dans le menu !
my $menuitem8 = Gtk2::RadioMenuItem->new_with_label($group,"Radio2") ;
$menu1->append($menuitem8) ;
$menuitem8->signal_connect("activate" ,\&on_radio) ;

my $menuitem9 = Gtk2::RadioMenuItem->new_with_label($group,"Radio3") ;
$menu1->append($menuitem9) ;
$menuitem9->signal_connect("activate" ,\&on_radio) ;

my $menuitem10 = Gtk2::SeparatorMenuItem->new() ;
$menu1->append($menuitem10) ;

#### Les cases à cocher aussi !
my $menuitem11 = Gtk2::CheckMenuItem->new_with_label("Check") ;
$menu1->append($menuitem11) ;
$menuitem11->signal_connect("toggled" ,\&on_check) ;

my $menuitem12 = Gtk2::SeparatorMenuItem->new() ;
$menu1->append($menuitem12) ;

my $menuitem13 = Gtk2::MenuItem->new_with_label("Quitter") ;
$menu1->append($menuitem13) ;
$menuitem13->signal_connect("activate" ,\&on_quitter,$window) ;

### Étape 4
my $menuitem14 = Gtk2::MenuItem->new_with_label("Fichier") ;

### Étape 5
$menuitem14->set_submenu($menu1) ;

### Étape 6
$menubar->append($menuitem14) ;

### Second sous-menu **/
### Étape 2
my $menu2 = Gtk2::Menu->new() ;

### Étape 3
my $menuitem15 = Gtk2::MenuItem->new_with_label("À propos de ...") ;
$menu2->append($menuitem15) ;
$menuitem15->signal_connect("activate" ,\&on_about,$window) ;

### Étape 4
my $menuitem16 = Gtk2::MenuItem->new_with_label(" ?") ;

### Étape 5
$menuitem16->set_submenu($menu2) ;

### Étape 6
$menubar->append($menuitem16) ;

### Creation de la deuxieme GtkVBox (pour les labels) */
my $vbox2 = Gtk2::VBox->new(FALSE, 0) ;

my $RadioLabel = Gtk2::Label->new("Radio 1 est actif") ;
$vbox2->pack_start($RadioLabel, TRUE, TRUE, 0) ;

my $CheckLabel = Gtk2::Label->new("Check est décoché") ;
$vbox2->pack_start($CheckLabel, TRUE, TRUE, 0) ;

my $TearoffLabel = Gtk2::Label->new("Menu attaché") ;
$vbox2->pack_start($TearoffLabel, TRUE, TRUE, 0) ;

### Ajout du menu à la fenêtre
$vbox->pack_start($menubar, FALSE, FALSE, 0) ;

### Ajout des labels à la fenêtre
$vbox->pack_start($vbox2, TRUE, TRUE, 0) ;
$window->show_all() ;

Gtk2->main() ;

#### Les fonctions de rappels
sub on_radio {
    my $widget = shift ;
    ### Récupérer le label du bouton radio actif
    my $RadioName = $widget->child->get_label() ;
    $RadioLabel->set_label(sprintf"%s est actif" ,$RadioName) ;
}
sub on_check{

    my $widget = shift ;
    my $Label ;
    ### Savoir si le GtkCheckMenuItem est coché ou non
    my $Coche = $widget->get_active() ;
    if ($Coche) {
        $Label = "Check est coché" ;
    }
    else {
        $Label ="Check est décoché" ;
    }
    $CheckLabel->set_label($Label) ;
}

sub on_tearoff {
    my ($widget,$menu) = @_ ;
    my $Label ;
    ### Savoir si le menu est détaché ou non */
    my $Detache = $menu->get_tearoff_state() ;
    if ($Detache) {
        $Label = "Menu détaché" ;
    }
    else {
        $Label = "Menu attaché" ;
    }
    $TearoffLabel->set_label($Label) ;
}

sub on_quitter{
    my ($widget,$window) = @_ ;
    my $dialog = Gtk2::MessageDialog->new ($window,
      [qw/modal destroy-with-parent/],
      'question' ,
      'yes no' ,
      "Voulez-vous vraiment \n quitter le programme ?") ;
    my $reponse = $dialog->run ;
    if ($reponse eq "yes") {
        Gtk2->main_quit ;
    }
    else {
        $dialog->destroy() ;
    }
}

sub on_about {
    my ($widget,$window) = @_ ;
    
    my $dialog = Gtk2::MessageDialog->new ($window,
      [qw/modal destroy-with-parent/],
      'info' ,
      'ok' ,
      "Gtk2 Perl tutoriel") ;
    $dialog->run ;
    $dialog->destroy() ;
}

Grâce aux deux premières parties du chapitre, nous avons appris à créer un menu. Vous avez pu remarquer que cette méthode peut s'avérer très fastidieuse si le menu comporte beaucoup d'éléments. Nous allons maintenant voir comment simplifier tout cela pour le biais de l'objet ItemFactory.

IX-D-1. Fonctionnement de ItemFactory▲

[$path,$accelerator,$callback,$callback_action,$item_type,$extra_data]

IX-D-2. Création des éléments du menu▲

sub fonction_callback
my ($window,$callback_action, $widget) = @_;
...
}

IX-D-3. Création du menu.▲

$accel = Gtk2::AccelGroup->new();

$item_factory = Gtk2::ItemFactory->new($container_type,$path, $accel);

$item_factory->create_items($window,@menu_items);

$menubar = $item_factory->get_widget($path);

$window->add_accel_group($accel);

IX-D-4. Exemple▲

Nous allons reprendre l'exemple de la première partie, mais cette en utilisant des éléments de menu de type <StockItem>.

 

Sélectionnez

# !/usr/bin/Perl -w

use strict ;
use Gtk2 '-init' ;
use constant TRUE => 1 ;
use constant FALSE => 0 ;

# Création de la fenêtre
my $window = Gtk2::Window->new("toplevel") ;
$window->set_title ("Les menus faciles") ;
$window->signal_connect (destroy => sub { Gtk2->main_quit }) ;
$window->set_default_size(320 ,200) ;

# Création de la GtkVBox
my $vbox = Gtk2::VBox->new(FALSE, 0) ;
$window->add($vbox) ;

my @menu_items = (
  [ "/ Fichier" ,undef,0 ,0 ,"<Branch>" ],
  [ "/Fichier/Nouveau" ,"<control>N" ,\&menuitem_cb,0 ,"<StockItem>" ,"gtk-new" ,"coucou" ],
  [ "/Fichier/Ouvrir" ,"<control>O" ,\&menuitem_cb,0 ,"<StockItem>" , 'gtk-open' ],
  [ "/Fichier/Enregistrer" ,"<control>S" ,\&menuitem_cb,0 ,"<StockItem>" ,'gtk-save' ],
  [ "/Fichier/Enregistrer sous..." , undef,\&menuitem_cb,0 ,"<StockItem>" ,'gtk-save' ],
  [ "/Fichier/sep1" ,undef,\&menuitem_cb,0 ,"<Separator>" ],
  [ "/Fichier/Quitter" ,"<control>Q" ,\&on_quitter,0 ,"<StockItem>" ,'gtk-quit' ],
  [ "/ Preferences" ,undef,0 ,0 ,"<Branch>" ],
  [ "/ Preferences/Couleur" ,undef,0 ,0 ,"<Branch>" ],
  [ "/ Preferences/Couleur/Rouge" ,undef,\&menuitem_cb,0 ,"<RadioItem>" ],
  [ "/ Preferences/Couleur/Vert" ,undef,\&menuitem_cb,0 ,"/Preferences/Couleur/Rouge" ],
  [ "/ Preferences/Couleur/Bleu" ,undef,\&menuitem_cb,0 ,"/Preferences/Couleur/Vert" ],
  [ "/ Preferences/Forme" ,undef,0 ,0 ,"<Branch>" ],
  [ "/ Preferences/Forme/Carre" ,undef,\&menuitem_cb,0 ,"<RadioItem>" ],
  [ "/ Preferences/Forme/Rectangle" ,undef,\&menuitem_cb,0 ,"/Preferences/Forme/Carre" ],
  [ "/ Preferences/Forme/Ovale" ,undef,\&menuitem_cb,0 ,"/Preferences/Forme/Rectangle" ],

  # Si vous aviez voulu justifier le menu suivant à droite, il aurait fallu utiliser :
  # <LastBranch> et non <Branch>. Les menus d'aide justifié à droite sont de nos
  # jours considérés comme une mauvaise idée.
  [ "/ ?" , undef, 0 , 0 , "<Branch>" ],
  [ "/ ?/ A propos" , undef, \&on_about, 0 ],
) ;

### Groupe de raccourci clavier
my $accel = Gtk2::AccelGroup->new() ;

### Création du menu
my $item_factory = Gtk2::ItemFactory->new("Gtk2::MenuBar" ,"<main>" , $accel) ;
### Récuperation des éléments du menu
$item_factory->create_items($window,@menu_items) ;
### Récuperation du widget pour l'affichage du menu
my $menubar = $item_factory->get_widget("<main>") ;
### Ajout du menu en haut de la fenêtre
$vbox->pack_start($menubar, FALSE, FALSE, 0) ;
### Association des raccourcis avec la fenêtre
$window->add_accel_group($accel) ;

$window->show_all() ;
Gtk2->main() ;

################ Fonctions de rappels

sub on_quitter{
    my ($widget,$window) = @_ ;
    my $dialog = Gtk2::MessageDialog->new ($window,
      [qw/modal destroy-with-parent/],
      'question' ,
      'yes no' ,
      "Voulez-vous vraiment \n quitter le programme ?") ;
      
    my $reponse = $dialog->run ;
    if ($reponse eq "yes") {
        Gtk2->main_quit ;
    }
    else {
        $dialog->destroy() ;
    }
}

sub on_about {
    my ($widget,$window) = @_ ;
    my $dialog = Gtk2::MessageDialog->new ($window,
      [qw/modal destroy-with-parent/],
      'info' ,
      'ok' ,
      "Gtk2 Perl tutoriel") ;
    $dialog->run ;
    $dialog->destroy() ;
}

sub menuitem_cb {
    my ($window, $callback_action, $widget) = @_ ;
    my $dialog = Gtk2::MessageDialog->new ($window,
      'destroy-with-parent' ,
      'info' ,
      'close' ,
      sprintf "Vous avez activé ou cliqué sur le menu item : \" %s\"" ,
      Gtk2::ItemFactory->path_from_widget ($widget)) ;
      
    # Ferme la boite de dialogue après la réponse de l'utilisateur
    $dialog->signal_connect (response => sub { $dialog->destroy ; 1 }) ;
    $dialog->show ;
}

Comme pour tous les autres widgets, c'est très simple :

$toolbar = Gtk2::Toolbar->new();

GtkToolbar étant un container, après l'avoir créée, il va falloir y ajouter des widgets. Cela se divise en deux catégories :

• les widgets habituels comme les GtkButton, GtkToggleButton, GtkRadio pour lesquels GtkToolbar fournit des fonctions qui s'occupent de la création de ces derniers ;
• les autres widgets que nous pouvons ajouter, mais c'est à nous de fournir les widgets donc il faudra les créer auparavant.

Voici les premières fonctions qui permettent d'ajouter un bouton avec du texte et (ou) une icône :

$toolbar->append_item ($text, $tooltip_text, $tooltip_private_text,
                             $icon, $callback, $user_data);
$toolbar->prepend_item ($text, $tooltip_text, $tooltip_private_text,
                             $icon, $callback, $user_data);
$toolbar->insert_item ($text,$tooltip_text,$tooltip_private_text,
                             $icon, $callback, $user_data, $position);

La première fonction ajoute un bouton à la suite des autres boutons, la seconde l'ajoute en première position et la dernière à une position spécifique. Le paramètre $text n'est autre que le label du bouton. Le troisième paramètre, $tooltip_text, est le texte de la bulle d'aide. Le paramètre suivant, tooltip_private_text, n'est plus utilisé, car la partie qui gère ce paramètre est obsolète. Il faut donc mettre ce paramètre à undef. Le paramètre $icon est là pour définir l'image qui sera associée au bouton. Les deux paramètres servent à connecter une fonction de rappel au clic sur le bouton. Le paramètre callback est en fait le nom de la fonction de rappel et $user_data est la donnée supplémentaire à passer à la fonction de rappel. Et pour terminer, la fonction insert_item possède un paramètre supplémentaire position qui détermine à quelle position le bouton doit être ajouté. Si cette valeur est soit trop grande, soit négative, cette fonction aura le même effet que append_item.

Ensuite il est possible de créer des éléments selon un type de widget prédéfini, comme Gtk2:::RadioButton, Gtk2::ToggleButton, Gtk2::Button :

$toolbar->append_element ($type, $widget, $text,
                         $tooltip_text, $tooltip_private_text, $icon, $callback, $user_data);
$toolbar->prepend_element ($type, $widget, $text,
                         $tooltip_text, $tooltip_private_text, $icon, $callback, $user_data);
$toolbar->insert_element ($type, $widget, $text,
                         $tooltip_text, $tooltip_private_text, $icon, $callback, $user_data,$position);

La majorité des paramètres de ces fonctions ont été détaillés précédemment, nous n'allons donc étudier que les nouveaux. Tout d'abord, le paramètre $type permet de définir le type de widget que nous allons ajouter, et peut prendre une de ces valeurs :

• 'space' pour ajouter un espace ;
• 'button' pour ajouter un bouton ;
• 'togglebutton' pour ajouter un bouton toggle ;
• 'radiobutton' pour ajouter un bouton radio ;
• 'widget' pour ajouter un widget quelconque.

Il y a ensuite le paramètre $widget qui doit être utilisé dans deux cas. Le premier cas est bien entendu, si nous ajoutons un élément de type 'widget'. Alors $widget sera en fait le widget que nous voulons ajouter.

Le deuxième cas est si nous ajoutons un élément de type 'radiobutton'. Nous avons vu que les boutons radiofonctionnaient par groupe, alors dans ce cas, pour grouper les boutons radio le paramètre $widget doit être un bouton radio ajouté précédemment pour que Gtk2-Perl puisse les grouper. Bien sûr, s'il s'agit du premier bouton radio, il faut mettre widget à undef. Dans tous les autres cas, le paramètre widget doit obligatoirement être undef.

Et maintenant, voilà les fonctions pour ajouter n'importe quel type de widget :

$toolbar->append_widget ($widget, $tooltip_text, $tooltip_private_text);
$toolbar->prepend_widget ($widget, $tooltip_text, $tooltip_private_text);
$toolbar->insert_widget ($widget, $tooltip_text, $tooltip_private_text, $position);

Cette fois, tout est simple, le paramètre $widget est simplement le widget que nous voulons ajouter. Il faudra tout de même connecter manuellement les signaux du widget ajouté.

Pour finir, il est possible d'utiliser les StockItem pour créer un bouton. Voici la fonction qui permet cela :

$toolbar->insert_stock ($stock_id, $tooltip_text, $tooltip_private_text,
$callback, $user_data, $position);

Le paramètre $stock_id est tout simplement l'identifiant du GtkStockItem qui figurera sur le bouton.

X-A-1. Les espaces▲

$toolbar->append_space();
$toolbar->prepend_space();
$toolbar->insert_space($position);

$toolbar->remove_space($position);

X-A-2. Orientation de la barre d'outils.▲

$toolbar->set_orientation($orientation) ;

$toolbar->get_orientation();

X-A-3. Les styles▲

$toolbar->set_style($style) ;

$toolbar->get_style();

X-A-4. La taille des icônes▲

$toolbar->set_icon_size($icon_size);

$toolbar->get_icon_size();

X-A-5. Exemple▲

Dans cet exemple, nous allons juste créer une barre d'outils dans laquelle nous allons ajouter quelques boutons dont deux d'entre eux permettront de changer l'orientation de la barre d'outils, une image et une zone de saisie. Vous remarquerez que le texte associé à l'icône n'est pas défini par l'utilisateur ce qui fait que le texte affiché est « suivant » alors que la flèche sert à placer la barre horizontalement. Un jour, je prendrais peut-être le temps de voir comment faire cela !

La méthode pour insérer l'image n'est certainement pas la plus pratique. Vous pouvez voir une autre approche en analysant le code de appwindow.pl fourni parmi les exemples de Gtk2-Perl.

 

Sélectionnez

# !/usr/bin/Perl -w
use strict ;
use Gtk2 '-init' ;
use constant TRUE => 1 ;
use constant FALSE => 0 ;
# l'image que l'on veut insérer dans la barre au format xpm
my @gtk_xpm = ('32 39 5 1' ,
                '. c none' ,
                '+ c black' ,
                '@ c #3070E0' ,
                '# c #F05050' ,
                '$ c #35E035' ,
                '................+...............' ,
                '..............+++++.............' ,
                '............+++++@@++...........' ,
                '..........+++++@@@@@@++.........' ,
                '........++++@@@@@@@@@@++........' ,
                '......++++@@++++++++@@@++.......' ,
                '.....+++@@@+++++++++++@@@++.....' ,
                '...+++@@@@+++@@@@@@++++@@@@+....' ,
                '..+++@@@@+++@@@@@@@@+++@@@@@++..' ,
                '.++@@@@@@+++@@@@@@@@@@@@@@@@@@++' ,
                '.+#+@@@@@@++@@@@+++@@@@@@@@@@@@+' ,
                '.+##++@@@@+++@@@+++++@@@@@@@@$@.' ,
                '.+###++@@@@+++@@@+++@@@@@++$$$@.' ,
                '.+####+++@@@+++++++@@@@@+@$$$$@.' ,
                '.+#####+++@@@@+++@@@@++@$$$$$$+.' ,
                '.+######++++@@@@@@@++@$$$$$$$$+.' ,
                '.+#######+##+@@@@+++$$$$$$@@$$+.' ,
                '.+###+++##+##+@@++@$$$$$$++$$$+.' ,
                '.+###++++##+##+@@$$$$$$$@+@$$@+.' ,
                '.+###++++++#+++@$$@+@$$@++$$$@+.' ,
                '.+####+++++++#++$$@+@$$++$$$$+..' ,
                '.++####++++++#++$$@+@$++@$$$$+..' ,
                '.+#####+++++##++$$++@+++$$$$$+..' ,
                '.++####+++##+#++$$+++++@$$$$$+..' ,
                '.++####+++####++$$++++++@$$$@+..' ,
                '.+#####++#####++$$+++@++++@$@+..' ,
                '.+#####++#####++$$++@$$@+++$@@..' ,
                '.++####++#####++$$++$$$$$+@$@++.' ,
                '.++####++#####++$$++$$$$$$$$+++.' ,
                '.+++####+#####++$$++$$$$$$$@+++.' ,
                '..+++#########+@$$+@$$$$$$+++...' ,
                '...+++########+@$$$$$$$$@+++....' ,
                '.....+++######+@$$$$$$$+++......' ,
                '......+++#####+@$$$$$@++........' ,
                '.......+++####+@$$$$+++.........' ,
                '.........++###+$$$@++...........' ,
                '..........++##+$@+++............' ,
                '...........+++++++..............' ,
                '.............++++...............') ;

my $item ;

# la fenêtre principale
my $window = Gtk2::Window->new('toplevel') ;
$window->signal_connect("destroy" , sub { Gtk2->main_quit() ; }) ;
$window->set_title("La barre d'outils") ;
$window->set_default_size(200 ,80) ;

my $vbox = Gtk2::VBox->new(FALSE,0) ;
$window->add($vbox) ;

#Création de la barre d'outils
my $toolbar = Gtk2::Toolbar->new() ;
$vbox->pack_start($toolbar,FALSE,FALSE,0) ;

$toolbar->insert_stock('gtk-new' ,'Nouveau' ,undef,\&on_clicked,'Nouveau' ,-1) ;
$toolbar->insert_stock('gtk-open' ,'Ouvrir' ,undef,\&on_clicked,'Ouvrir' ,-1) ;
$toolbar->insert_stock('gtk-save' ,'Enregistrer' ,undef,\&on_clicked,'Enregistrer' ,-1) ;
$toolbar->insert_stock('gtk-quit' ,'Quitter' ,undef,\&quitter,undef,-1) ;

# Insertion d'un espace
$toolbar->insert_space(10) ;

# On veut maintenant insérer une image dans la barre d'outils.
# On crée d'abord un objet Gtk2::Gdk::Pixbuf à partir du fichier xpm
# présent plus haut.
my $pixbuf = Gtk2::Gdk::Pixbuf->new_from_xpm_data(@gtk_xpm) ;

# Nous devons ensuite créer une image, car il faut que l'objet à ajouter
# à la barre soit un héritier de Gtk2::Widget.
my $image = Gtk2::Image->new_from_pixbuf($pixbuf) ;
my $icon_button = $toolbar->append_item ("Image" , "Une petite image" , undef,
$image, \&on_clicked, 'Image') ;

# Insertion d'un espace
$toolbar->insert_space(10) ;

# Création à partir de stock. Ces deux icônes permettent de changer
# l'orientation de la barre
$toolbar->insert_stock('gtk-go-forward' ,'horizontale' ,undef,\&on_orientation_change,'horizontal' ,-1) ;
$toolbar->insert_stock('gtk-go-down' ,'verticale' ,undef,\&on_orientation_change,'vertical' ,-1) ;

# Insertion d'un espace
$toolbar->insert_space(10) ;

# Insérer une zone de saisie se fait très facilement.
my $entry = Gtk2::Entry->new() ;
$toolbar->append_widget($entry, "Une petite zone de saisie" , undef) ;


# On règle la taille des icônes
$toolbar->set_icon_size('button') ;

# Affichage uniquement des icônes
$toolbar->set_style('icons') ;

##### Un menu à options pour changer la taille des icônes
my $opt1 = new Gtk2::OptionMenu() ;
my $menu1 = new Gtk2::Menu() ;
my $hbox1 = Gtk2::HBox->new(TRUE,0) ;
$vbox->pack_start($hbox1,FALSE,FALSE,0) ;
my $label1 = Gtk2::Label->new ("Taille des icônes") ;
$hbox1->pack_start($label1,FALSE,FALSE,0) ;
    
# On automatise la création des options
my @choix_taille=('menu' ,'small-toolbar' ,'large-toolbar' ,'button' ,'dnd' ,'dialog') ;
foreach (@choix_taille) {
    $item = make_menu_item($_ , \&change_taille_icone,$_) ;
    $menu1->append($item) ;
}
# On place le tout dans le menu puis dans la boite
$opt1->set_menu($menu1) ;
$hbox1->pack_start($opt1, FALSE, FALSE, 0) ;

##### Un menu options pour changer le style de la barre
my $opt2 = new Gtk2::OptionMenu() ;
my $menu2 = new Gtk2::Menu() ;
my $hbox2 = Gtk2::HBox->new(TRUE,0) ;
$vbox->pack_start($hbox2,FALSE,FALSE,0) ;
my $label2 = Gtk2::Label->new ("Style") ;
$hbox2->pack_start($label2,FALSE,FALSE,0) ;

my @choix_style=('icons' ,'text' ,'both' ,'both-horiz') ;
foreach (@choix_style) {
    $item = make_menu_item($_, \&change_style, $_) ;
    $menu2->append($item) ;
}
# On place le tout dans le menu puis dans la boite
$opt2->set_menu($menu2) ;
$hbox2->pack_start($opt2, FALSE, FALSE, 0) ;
    
$window->show_all() ;

Gtk2->main() ;

sub on_orientation_change {
    my ($self,$orientation) = @_ ;
    $toolbar->set_orientation($orientation) ;
}

# Fonctions pratiques
sub make_menu_item {
    my ($name, $callback, $data) = @_ ;
    my $item ;
    $item = new Gtk2::MenuItem($name) ;
    $item->signal_connect("activate" , $callback, $data) ;
    $item->show() ;
    return $item ;
}

sub change_taille_icone {
    my ($item, $taille) = @_ ;
    $toolbar->set_icon_size($taille) ;
}

sub change_style {
    my ($item, $style) = @_ ;
    $toolbar->set_style($style) ;
}

sub on_clicked {
    my ($item, $message) = @_ ;
    print "Vous avez cliqué sur $message !\n" ;
}

sub quitter{
    Gtk2->main_quit() ;
}

Le widget éditable est la classe de base du widget entry dont l'objet est de gérer des chaines de caractères courtes. Cette classe ne peut être instanciée (il n'y a pas de fonction new()) et fournit uniquement les fonctionnalités communes aux widgets textes. Tous les widgets qui éditent du texte vous permettent de sélectionner une région de texte avec :

$editable->select_region($start, $end);

Ou le texte sélectionné est composé des caractères de la position $start jusqu'à la position $end non inclus. Si $end est négatif, alors il compte à rebours à partir de la fin du texte. Du texte peut être inséré à une certaine position en utilisant :

$editable->insert_text($new_text, $position);

$new_text est la chaine à insérer et $position la position où il faut placer le texte. Des caractères peuvent être effacés avec :

$editable->delete_text($start, $pos);

Comme pour select_region, les caractères à effacer sont compris entre $start et $end. Vous pouvez récupérer des caractères avec :

$editable->get_chars($start, $end);

Si vous avez sélectionné du texte, vous pouvez le couper et le placer dans le bloc note avec :

$editable->cut_clipboard();

Cela prend les caractères sélectionnés pour les placer dans le bloc note et les efface du widget éditable. Vous pouvez aussi copier le texte sélectionné dans le bloc note.

$editable->copy_clipboard();

Les caractères sont copiés dans le bloc-note, mais pas effacé du widget éditable. Le texte du bloc-note peut être collé dans le widget éditable à l'endroit où se trouve le curseur :

$editable->paste_clipboard();

Pour effacer le texte sélectionné :

$editable->delete_selection();

La position du curseur peut être déclarée et retrouvée avec :

$editable->set_position($position);
$editable->get_position();

Les widgets éditables peuvent être en lecture seule ou bien éditable :

$editable->set_editable($is_editable);

$is_editable est une valeur vraie ou fausse qui détermine si le widget éditable peut être édité ou non par l'utilisateur.

Le widget éditable possède un grand nombre de signaux disponibles qui sont :

L'utilisation de ces signaux devrait être évidente. Si vous avez une question sur leur utilisation, consulter la documentation GTK. Le seul commentaire que je ferais est que vous pouvez émettre le signal 'changed' en appelant la fonction :

$editable->changed();

XIV-A-1. Le widget d'entrée▲

Le widget d'entrée permet de taper du texte dans une boite d'une seule ligne. Le texte peut être placé avec des appels de fonctions qui déterminent si le nouveau texte doit remplacer, se placer devant ou après le contenu actuel du widget entrée. Pour créer un widget d'entrée :

 

Sélectionnez

$entry = Gtk::Entry->new();

Il existe plusieurs fonctions qui modifient le texte contenu dans le widget d'Entrée :

 

Sélectionnez

$entry->set_text($text);
$entry->append_text($text);
$entry->prepend_text($text);

La fonction set_text() déclare le contenu du widget Entrée remplaçant le contenu présent. Les fonctions append_text() et prepend_text() permettent de placer du texte après ou avant le contenu du widget.

Si vous utilisez une Entrée et que vous ne voulez pas que le texte entré soit visible, par exemple quand vous entrez un mot de passe, vous pouvez utiliser la fonction suivante qui prend comme argument une valeur vraie ou fausse :

 

Sélectionnez

$entry->set_visibility($visible);

Si nous voulons attraper le moment ou l'utilisateur a rentré du texte, nous pouvons connecter un signal 'activate' ou 'changed'. 'activate' se manifeste quand l'utilisateur appuie sur la touche « Entrée » à l'intérieur du widget. 'changed' se manifeste quand le texte change, pour chaque caractère entré ou effacé.

XIV-A-1-a. Exemple▲

 

Sélectionnez

# !/usr/bin/Perl -w

use strict ;
use Gtk2 '-init' ;

# Variables convenables pour vrai et faux
use constant TRUE => 1 ;
use constant FALSE => 0 ;

my $window = Gtk2::Window->new("toplevel") ;
$window->set_default_size(200 , 100) ;
$window->set_title("L'entrée texte") ;
$window->signal_connect("delete event" , sub { Gtk2->main_quit() ; }) ;

my $vbox = Gtk2::VBox->new(FALSE, 0) ;
$window->add($vbox) ;
$vbox->show() ;

my $entry = Gtk2::Entry->new() ;
$entry->signal_connect("activate" , \&enter_callback, $entry) ;
$entry->set_text("Salut ") ;
$entry->append_text("à tous !") ;
$entry->select_region(0 , length($entry->get_text())) ;
$vbox->pack_start($entry, TRUE, TRUE, 0) ;
$entry->show() ;

my $hbox = Gtk2::HBox->new(FALSE, 0) ;
$vbox->add($hbox) ;
$hbox->show() ;

my $check1 = Gtk2::CheckButton->new("Editable") ;
$hbox->pack_start($check1, TRUE, TRUE, 0) ;
$check1->signal_connect("toggled" , \&entry_toggle_editable, $entry) ;
$check1->set_active(TRUE) ;
$check1->show() ;

my $check2 = Gtk2::CheckButton->new("Visible") ;
$hbox->pack_start($check2, TRUE, TRUE, 0) ;
$check2->signal_connect("toggled" , \&entry_toggle_visibility, $entry) ;
$check2->set_active(TRUE) ;
$check2->show() ;

my $button = Gtk2::Button->new_from_stock("gtk-close") ;
$button->signal_connect("clicked" , sub { Gtk2->main_quit() ; }) ;
$vbox->pack_start($button, TRUE, TRUE, 0) ;
$button->can_default(TRUE) ;
$button->grab_default() ;
$button->show() ;

$window->show() ;

main Gtk2 ;

### Fonctions de rappels
sub enter_callback {
    my ($widget, $entry) = @_ ;
    my $entry_text = $entry->get_text() ;
    print("L'entrée texte contient : $entry_text\n") ;
}

sub entry_toggle_editable {
    my ($checkbutton, $entry) = @_ ;
    $entry->set_editable($checkbutton->get_active) ;

sub entry_toggle_visibility {
    my ($checkbutton, $entry) = @_ ;
    $entry->set_visibility($checkbutton->get_active) ;
}

Les boites de messages sont des boites de dialogue prédéfinies. Elles permettent d'afficher un message à côté d'une icône. Pour créer une boite de message :

my $dialog = Gtk2::MessageDialog->new ( $fenetre_parente,
                    $flags,$type,$bouton,..
                    $message);

Le principe de fonctionnement est exactement le même que pour les fenêtres de dialogues. L'intérêt est ici de vous faire économiser du code et d'assurer une certaine homogénéité pour les applications Gtk2-Perl. Les quatre types de fenêtres sont :

• 'info' ;
• 'question' ;
• 'error' ;
• 'warning'.

XV-A-1. Exemple▲

# !/usr/bin/Perl -w

use strict ;
use Gtk2 '-init' ;
use constant TRUE => 1 ;
use constant FALSE => 0 ;

my $window = new Gtk2::Window('toplevel') ;
$window->set_border_width(15) ;
$window->set_title('Salut les boutons !') ;
$window->signal_connect('delete event' , sub {Gtk2->main_quit() ;}) ;

my $box = Gtk2::HBox->new(FALSE,10) ;
$window->add($box) ;

### Liste des différents types de fenêtres de dialogue
my @liste =('info' ,'error' ,'warning' ,'question') ;
### On lance ensuite un constructeur de boutons
foreach (@liste) {
    creer_bouton($_) ;
}

# On montre la boite
$box->show ;

# On montre la fenêtre
$window->show() ;

# On lance la boucle principale.
Gtk2->main ;

### La fonction de rappel qui est appelé quand on a cliqué sur un bouton.
sub rappel{
    my ($widget,$type)=@_ ;
    my $dialog = Gtk2::MessageDialog->new ($window,
      [qw/modal destroy-with-parent/],
      $type,
      'ok' ,
      "Une boite de dialogue de type : $type ") ;
    
    # On ajoute un nouveau bouton à la boite de dialogue. On associe à ce bouton
    # l'identifiant 'cancel'
    $dialog->add_button("Salut !" ,'cancel') ;
    
    # Si l'utilisateur clique sur le bouton "Salut", on lui répond poliment
    if ('cancel' eq $dialog->run) {
        my $dialog2 = Gtk2::Dialog->new ("Bonjour !" , $dialog,
          [qw/modal destroy-with-parent/],
          'gtk-ok' =>'OK') ;
        my $label = Gtk2::Label->new("Comment vas-tu ?") ;
        $dialog2->vbox->add($label) ;
        $label->show() ;
        
        $dialog2->run() ;
        # le code est bloqué là tant que l'utilisateur ne clique pas sur un bouton
        $dialog2->destroy ;
    }
    $dialog->destroy ;
}

### Cette fonction crée les différents boutons
sub creer_bouton {
    my $texte = shift ;
    my $button = Gtk2::Button->new($texte) ;
    $button->signal_connect('clicked' , \&rappel, $texte) ;
    $box->pack_start($button,TRUE,TRUE,5) ;
    $button->show ;
}

XV-B-1. Créer une boite de dialogue de sélection de fichiers▲

$file_dialog = Gtk2::FileSelection->new($title);