Programmation Graphique avec Gtk2-Perl [30 mn de lecture - paru le 10/7/2004 10:34:59 AM - Public : Confirmé]

Auteur

Przemyslaw BRODACKI Elève-Ingénieur Supinfo Paris Promotion SUPINFO 2004    Lui écrire    Tous les projets de cet auteur    Le mini-CV de cet auteur

1. Eléments de base

Nous découvrirons dans ce chapitre quelques éléments de base pour bien commencer.

La première étape est la création de la fenêtre car sans elle, pas d'application graphique.

1.1. Fenêtres

La fenêtre est le tout premier conteneur qui, lui, est alloué par le gestionnaire des fenêtres. Comme nous l'avons vu dans l'introduction cette procédure est aussi simplifié que la placement de n'importe quel objet dans la fenêtre. Voici donc comment on crée une simple fenêtre.

my $fenetre = Gtk2::Window->new('toplevel');

L'argument 'toplevel' signifie que la fenêtre qui va être crée est celle alloué par le gestionnaire de fenêtres. Elle aura les caractéristiques par défaut car nous n'avons pas spécifié d'autre parametres. La taille par defaut est de 200x200. L'autre type de fenêtre possible est une fenêtre 'popup'.

Les propriétés et les méthodes des fenêtres sont très nombreuses. Il est donc impossible de les détailler un par un. Voici donc celle qui sont les plus utiles.

Permet de mettre un titre sur la fenêtre:

$fenetre->set_title( $titre );

La fenêtre peut contenir d'autres objects et il est donc possible de definir l'objet qui portara le focus et celle qui l'aura par défaut:

$fenetre->set_focus( $widget );

$fenetre->set_default( $widget );

La politique de redimensionnement:

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

Les arguments sont booléens:

- allow_shrink autorise ou non la réduction de la fenêtre en dessous de la taille définie
- allow_grow autorise ou non l'agrandissement au dela de la taille définie
- auto_shrink spécifie ou non le redimensionnement automatique

La taille de la fenêtre et sa position:

$fenetre->set_default_size( $width, $height );
$fenetre->set_position( $position );

Les dimmensions sont en pixels, et la position peut être une des suivantes:

- none signifie que c'est le gestionnaire des fenêtres qui se charge du placement
- center signifie que la fenêtre apparaitra au centre du bureau
- mouse signifie que la fenêtre apparaitra sous la souris

Noublions pas que pour afficher la fenêtre il faut lui dire de s'afficher:

$fenetre->show();

Et pour lancer la boucle principale il faut bien entendu:

Gtk2- > main ;

Les fenêtres ont une particularité etrange car elles ne peuvent contenir qu'un seul objet. A ce stade la programmation graphique ne permettrait la création de boîtes de dialogue du type "Cliquez OK". Heureusement il y a des objets qui, eux, sont capables d'en contenir d'autres: les boites et les tables.

1.2. Boîtes

Une boîte est un conteneur qui contient d'autres objet. Il en existe de deux sortes:

- Les boîtes à empilement vertical (VBOX)
- Les boîtes à empilement horizontal (HBOX)

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

Les variables passées en parametre sont:

- homogenous (bool) signale si oui ou non les objets dans la boite disposent du même espace
- spacing (int) définit l'espace en pixels à laisser entre 2 objets

Pour placer les objets dans les boites il n'y a rien de plus simple:

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

La première empile les objets en commencant par le début et la seconde par la fin avec comme paramètres:

- child est l'objet à empiler
- expand signale si oui ou non les objets doivent utiliser tout l'espace qui lui est réservé (un peu comme le tag 'justify' pour le texte dans un editeur)
- fill signale si oui ou non l'objet doit remplir l'espace reservé (un peu comme width=100% dans html)
- padding est l'espace minimal entre les objets

Il y a bien entendu des propriétés permettant de modfier tous les aspects des boites à la volée.

Il est évident que si on crée un objet HBOX dans lequel on range horizontalement des boites VBOX on aura une véritable calculatrice :). L'opération d'empilement par en bas ou par en haut pour obtenir le résultat souhaité peut vite devenir un cauchemarre. La solution vient des tables qui permettent de diviser l'aplication en zones de taille égale et de remplir les zones à volonté avec n'importe quel objet ou de les laisser vides.

1.3. Tables

La différence entre une table et une boite est bien entendu la deuxième dimension. Il sera toujours possible, pour arriver au résultat souhaité, de combiner les deux. L'origine de départ d'une table est le coin en haut à gauche. Les cases ne sont pas numérotées mais utilisent un système de coordonnées: une case commence en X à 0 et finit à 1, en Y à 0 et finit à 1. Une deuxième case à sa droite commence en X à 1 et finit à 2, en Y à 0 et finit à 1... On peut ainsi définir une zone qui occupe plusieures cases (par exemple les deux cases en bas à droite): X: début à 1 et fin à 3, Y: début à 2 et fin à 3.

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

Pour en créer une:

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

Permet de créer une table de nb_lignes sur nb_colones. Homogenous est un booléen qui signale si les champs doivent tous avoir la même taille, celle de la case la plus grande.

Pour ajouter les objets dans la table, rien de plus simple:

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

Les paramètres sont les suivants:

- child est l'objet à ajouter
- left/right/top/bottom_attach sont les coordonnées du champ où sera placé l'objet
- xoptions/yoptions spécifient les options de rangement: 'shrink', 'fill' et 'expand' pour réduire les objets à la taille de la fenêtre, pour agrandir les objets à la taille du champ ou pour agrandir la table à la taille de la fenêtre. Il est possible de les combiner en les mettant entre crochets [opt1,opt2]
- xpadding/ypadding est le padding en pixels

A part le padding, on peut aussi modifier l'espacement (spacing):

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

C'est donc un espace vide de spacing pixels qui est ajouté en dessous/à droite de la ligne/colone choisie. Si la ligne ou la colonne est omise, l'espacement est adapté à toutes les lignes/colonnes.

1.4. Labels & Cadres

Les labels sont de simples testes afichés dans les fenêtres:

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

Le parametre string est le texte affiché.

On peut par la suite retrouver le texte affiché ou bien le modifier:

$label->get();
$label->set_text($string);

Dans le label le texte peut être aligné à gauche, centré, aligné à droite ou justifié:

$label->set_justify( $type );

où types est: 'left', 'center', 'right' ou 'fill'.

Il est toujours plus sympa de mettre un joli cadre autour du texte:

$cadre = Gtk2::Frame->new( ”Titre du Cadre/Label ” ) ;

Il ne suffit plus que l'ajouter autour du label souhaité:

$cadre->add( $label ) ;

1.5. Boutons

Les boutons sont des éléments d'interaction avec l'utilisateur. Pour en créer un:

$bouton = Gtk2::Button->new( $label );

avec label comme texte affiché sur le bouton, qui peut être omis pour obtenir un bouton vide.

Le label d'un bouton est en fait un objet fils se trouvant dans le bouton. pour le modifier il faut donc passer par la méthode child:

$bouton->child->set( "nouveau label " );

Les boutons réagissent aux actions et donc aux signaux émis lors de l'exécution d'une action. Les signaux sont interceptés par une méthode d'un objet parrent à tous les objets qui est Glib::object et la méthode en question permet de se connecter aux signaux pour en détecter la présence:

$bouton->signal_connect( ”clicked” , \&ClickedButtonEvent ) ;

Le premier parametre est le signal à intercepter, et le deuxième la fonction à executer. Les signaux générés par un bouton peuvent être:

- pressed donc appuyé
- released donc relâché
- clicked donc appuyé puis relâché
- enter lorsque la souris passe au dessus du bouton
- leave lorsque la souris sort de la surface du bouton

Il est possible de jouer sur le relief du bouton pour montrer par exemple un bouton qui s'enfonce quand la souris passe dessus. Pour savoir le relief courant et le changer:

$bouton->get_relief();
$bouton->set_relief($style);  

où le style est 'normal', 'half' donc plus mince et 'none' pour aucun relief.