Introduction à Perl/Tk

La liste suivante énumère toutes les options disponibles lors d'un appel à pack. Les valeurs par défaut sont mises en gras (ce qui signifie que, si vous n'utilisez pas cette option, vous obtiendrez les effets de cette valeur pour cette option).

-side => 'left' | 'right' | 'top' | 'bottom'

• Place le widget contre le bord spécifié de la fenêtre ou du cadre.

-fill => 'none' | 'x' | 'y' | 'both'

• Force le widget à remplir dans la direction spécifiée le rectangle qui lui a été alloué.

-expand => 1 | 0

• Force le rectangle alloué au widget à remplir l'espace disponible restant dans la fenêtre ou le cadre.

-anchor => 'n' | 'ne' | 'e' | 'se' | 's' | 'sw' | 'w' | 'nw' | 'center'

• Ancre le widget dans le rectangle qui lui a été alloué.

-after => $autrewidget

• Met $widget après $autrewidget dans l'ordre de placement.

-before => $autrewidget

• Met $widget avant $autrewidget dans l'ordre de placement.

-in => $autrefenetre

• Place $widget dans $autrefenetre au lieu de le mettre dans le parent de $widget, ce qui est le cas par défaut.

-ipadx => montant

• Augmente la dimension horizontale du widget par montant x 2.

-ipady => montant

• Augmente la dimension verticale du widget par montant x 2.

-padx => montant

• Place des espaces de remplissage à gauche et à droite du widget.

-pady => montant

• Place des espaces de remplissage au-dessus et en dessous du widget.

Chaque fenêtre (ou cadre) a quatre côtés haut, bas, gauche et droite. Le placeur utilise ces bords comme points de référence pour les widgets. Par défaut pack place les widgets contre le haut de la fenêtre ou du cadre.

Vous pouvez choisir le bord contre lequel sera placé un widget en utilisant l'option -side :

-side => 'left' | 'right' | 'top' | 'bottom'

Si, par exemple, vous souhaitez placer votre bouton contre le bord gauche de la fenêtre, vous pouvez préciser -side => 'left'.

En utilisant notre exemple « Bonjour tout le monde » comme base, voyons ce qui se passe lorsque l'on place notre bouton contre les différents bords (figure 2.5).

La seule chose qui changera sera la partie ->pack de la ligne de création du bouton. Nous modifierons aussi la chaîne « Bonjour tout le monde » dans l'instruction $mw->title afin de montrer l'option de pack utilisée.

La forme employée est :

$mw->Button(
    -text    => 'Fin',
    -command => sub {
        exit;
    }
)->pack( -side => 'POSITIONNEMENT' );

où POSITIONNEMENT peut être top, bottom, left ou right.

Les fenêtres montrées ici ont été légèrement agrandies pour mettre en évidence les différences résultant de l'utilisation des diverses valeurs de -side. Normalement, la fenêtre sera seulement de la taille requise pour afficher le bouton. Lorsque vous décidez de la façon de placer les widgets, il est toujours préférable de voir ce qui se passe lorsque vous agrandissez ou réduisez la fenêtre. Assurez-vous que le comportement obtenu est celui recherché.

Pour l'instant pack semble assez simple, mais qu'en est-il si vous souhaitez placez plus d'un bouton dans votre application ? Que se passe-t-il si l'on ajoute simplement d'autres boutons ?

$mw->Button( -text => 'Fin 1', -command => sub { exit; } )->pack;
$mw->Button( -text => 'Fin 2', -command => sub { exit; } )->pack;
$mw->Button( -text => 'Fin 3', -command => sub { exit; } )->pack;
$mw->Button( -text => 'Fin 4', -command => sub { exit; } )->pack;

Comme la valeur par défaut de -side est top, on s'attend à ce qu'ils soient tous entassés contre le haut de la fenêtre ; n'est-ce pas ? C'est un peu ça. Le placeur alloue de l'espace pour chaque widget, puis manipule le widget dans cet espace, et cet espace dans la fenêtre.

La figure 2.6 montre à quoi ressemble la fenêtre avec les quatre boutons « Fin » ; la section suivante explique pourquoi ils sont placés ainsi.

Lorsqu'il doit placer un widget, le placeur recherche d'abord le bord (haut, bas, droite, gauche) à utiliser. Puis, il réserve une zone rectangulaire invisible sur toute la longueur de ce bord pour ne l'utiliser qu'avec ce widget.

Dans la figure 2.7, le rectangle en trait continu représente notre fenêtre (ou cadre) vide et le rectangle en pointillé est la zone rectangulaire que le placeur réserve pour le premier bouton. En réalité, il occupe toute la largeur ou la hauteur de la fenêtre, mais pour mieux le mettre en évidence, nous l'avons un peu indenté.

Les dimensions de la boîte en pointillé, que nous appellerons le rectangle alloué, sont calculées d'après la taille du widget. Pour les bords haut et bas, le rectangle alloué est aussi large que la fenêtre et aussi haut que le widget qui y sera placé, mais pas plus. Pour les bords droit et gauche, ce rectangle est aussi haut que la fenêtre, et aussi large qu'il est nécessaire pour convenir au widget, mais pas plus.

Jusqu'à maintenant, nos exemples ont utilisé des boutons dans lesquels le texte du bouton détermine sa largeur. Si nous créons un bouton contenant le texte « Fin », et un autre avec le texte « Fin, Terminé, Stop », ce second bouton sera beaucoup plus large que le premier. Lorsque ces deux widgets seront placés contre le bord gauche ou droit de la fenêtre, le second bouton aura un rectangle alloué plus large que celui du premier. Si nous les plaçons tous les deux contre les bords haut et bas, les rectangles alloués seront de la même hauteur et de la même largeur car cette dernière est déterminée par la fenêtre, pas par le widget.

Lorsque la taille du rectangle alloué a été déterminée, le widget est placé à l'intérieur selon les options utilisées et/ou les valeurs par défaut de ces options. Je passerai plus tard en revue ces options et la façon dont elles affectent le rectangle alloué.

Une fois que le premier widget a été placé dans la fenêtre, la taille de la zone disponible pour les rectangles suivants est plus petite car le premier rectangle alloué a utilisé une partie de cet espace (voir la figure 2.8).

Quand plusieurs boutons sont placés contre les différents bords de la même fenêtre, les résultats dépendent de l'ordre utilisé.

Nous commencerons par placer un bouton en haut, un autre en bas, et les autres à droite et à gauche :

$mw->Button( -text => "HAUT",   -command => sub { exit } )->pack( -side => 'top' );
$mw->Button( -text => "BAS",    -command => sub { exit } )->pack( -side => 'bottom' );
$mw->Button( -text => "DROIT",  -command => sub { exit } )->pack( -side => 'right' );
$mw->Button( -text => "GAUCHE", -command => sub { exit } )->pack( -side => 'left' );

Les rectangles alloués pour cette fenêtre ressembleront à ceux du schéma de la figure 2.9.

Normalement, le widget est laissé à sa taille par défaut, qui est habituellement plus petite que le rectangle qui lui a été alloué. Si l'option -fill est utilisée, le widget changera lui-même de taille pour remplir le rectangle alloué en fonction de la valeur indiquée. Les valeurs possibles sont :

• -fill => 'none' | 'x' | 'y' | 'both'

L'utilisation de la valeur 'x' modifiera la taille du widget selon l'axe des x. De même, 'y' fera que le widget s'agrandira selon l'axe des y. -f1ll => 'both' est un bon moyen de voir exactement la taille et l'emplacement donné au rectangle car 'both' modifie la taille du widget dans les directions x et y. Reprenons notre exemple des quatre boutons, en précisant -fill => 'both' :

$mw->Button( -text => "HAUT",   -command => sub { exit } )->pack( -side => 'top',    -fi11 => 'both' );
$mw->Button( -text => "BAS",    -command => sub { exit } )->pack( -side => 'bottom', -fi11 => 'both' );
$mw->Button( -text => "DROIT",  -command => sub { exit } )->pack( -side => 'right',  -fill => 'both' );
$mw->Button( -text => "GAUCHE", -command => sub { exit } )->pack( -side => 'left',   -fi11 => 'both' );

La figure 2.11 montre la fenêtre que l'on obtient.

Si nous inversons le bouton que nous créons en premier, nous obtenons un résultat différent. La fenêtre de la figure 2.12 a été créée en plaçant les widgets dans l'ordre droit, gauche, haut et bas.

La figure 2.13 est le résultat d'encore un autre ordonnancement, qui montre bien que les rectangles alloués changent de taille selon ce qui est placé en premier.

Une utilisation classique de -fill est avec les widgets utilisant des barres de défilement : les boîtes de liste, les canevas et les textes. Habituellement, les barres de défilement se trouvent sur le côté de la fenêtre et l'on souhaite que la boîte de liste remplisse la zone restante. Voyez le chapitre 6, Barres de défilement, et le chapitre 7, Le widget boîte de liste, pour plus d'informations.

L'option -expand manipule le rectangle alloué, non le widget qu'il contient. La valeur associée à -expand est un booléen.

• -expand => 1 | 0

Avec une valeur vraie, le rectangle alloué s'agrandira dans tout l'espace disponible restant dans la fenêtre selon le bord sur lequel le widget a été placé.

Les widgets placés sur les bords droit ou gauche s'agrandiront selon l'axe horizontal. Ceux placés sur les bords haut ou bas s'agrandiront dans la direction verticale. Si plus d'un widget est placé avec l'option -expand positionnée, l'espace supplémentaire dans la fenêtre est divisé à parts égales entre tous les rectangles alloués qui le veulent.

Dans les figures 2.10 ou 2.11, nous avons constaté qu'il restait un peu de place au centre de la fenêtre et qu'il n'était occupé par aucun widget. Si nous modifions le code et que nous ajoutons -expand => 1 à la liste des options de pack pour chaque bouton, le résultat sera celui affiché par la figure 2.14.

Remarquez que la figure 2.14 laisse l'option -fill => 'both' dans le code. Si nous omettons l'option -fill, les boutons garderont leur taille originale, mais les rectangles alloués (invisibles) s'étendront sur l'espace restant dans la fenêtre (voir la figure 2.15).

Dans la figure 2.15, les boutons sont centrés dans leurs rectangles alloués à cause de la valeur par défaut de l'option -anchor, qui est 'center'.

L'option -anchor manipule le widget à l'intérieur du rectangle alloué en l'ancrant à l'endroit indiqué par la valeur de l'option. Elle utilise les points cardinaux comme références.

• -anchor => 'e' | 'w' | 'n' | 's' | 'ne' | 'nw' | 'se' | 'sw' | 'center'

La figure 2.16 montre ces emplacements dans un exemple de rectangle alloué.

La valeur par défaut de -anchor est 'center', qui place le widget au centre du rectangle qui lui a été alloué. À moins que l'option -expand n'ait une valeur vraie, cela ne changera pas grand-chose à quoi que ce soit dans la fenêtre. Ainsi que nous l'avons vu dans la figure 2.17, qui montre l'effet de l'utilisation de l'option -expand => 1, il est évident que le widget colle à cette position centrale lorsque la fenêtre change de taille.

La figure 2.18 montre ce que donnent -anchor => 'e' et -anchor => 'w' si toutes les autres valeurs par défaut sont utilisées pour placer le widget.

Rappelez-vous que le rectangle alloué est créé en fonction du bord contre lequel est placé le widget, certaines combinaisons sembleront donc n'avoir aucun effet. Par exemple :

$mw->Button( -text => "Fin", -command => sub { exit } )

->pack(-side => 'top', -anchor => 'n');

Ce bout de code laissera le widget exactement au même endroit qu'il aurait été si l'option -anchor n'avait pas été précisée car le rectangle alloué ne change pas du tout de taille. Si l'option -expand est aussi utilisée, le widget collera au côté nord de la fenêtre lorsque la taille de celle-ci sera modifiée. Si -anchor => 's' avait été utilisée, le widget aurait collé au côté sud de la fenêtre lors du changement de taille de celle-ci.

L'option -anchor est le plus souvent utilisée pour aligner plusieurs widgets d'un coup. Les figures 2.19 et 2.20 montrent deux exemples classiques.

Parfois, lorsque -side et -anchor sont utilisées ensemble, les résultats ne semblent pas être ceux attendus. Gardez toujours à l'esprit ce rectangle alloué invisible et la façon dont il affecte ce que vous voyez à l'écran.

Chaque fenêtre contenant des widgets garde la trace de ceux-ci dans une liste ordonnée. L'ordre de cette liste est normalement déterminé par celui dans lequel les widgets ont été placés. Le dernier placé est le dernier de la liste. En utilisant l'option -after, on peut modifier l'ordre par défaut en spécifiant après quel widget sera placé notre nouveau widget. À l'opposé, si l'on utilise l'option -before, on peut placer le nouveau widget avant un autre déjà placé :

-after  => $autrewidget
-before => $autrewidget

Créons, par exemple, quatre boutons ($widget1, $widget2, $widget3, $widget4) et

plaçons-en trois pour commencer. L'appel de pack pour $widget4 pourrait alors être :

$widget4->pack(-after => $widget1);

La figure 2.21 montre deux fenêtres : l'une avant que $widget4 ne soit placé, l'autre après.

Pour placer $widget4 devant $widget1, on utilisera l'instruction :

$widget4->pack(-before => $widget1);

Nous en constatons les effets sur la figure 2.22.

Le dernier moyen de forcer pack à modifier la taille du widget est d'utiliser les options de remplissage. Le premier ensemble de ces options affecte le widget lui-même en ajoutant quelque chose à sa taille par défaut. Des montants différents ou identiques peuvent être ajoutés dans les directions x et y. Pour préciser le remplissage voulu dans la direction x, on utilise l'option -ipadx :

-ipadx => montant

On spécifie le remplissage dans la direction y de cette façon :

-ipady => montant

montant est un nombre représentant une distance d'écran. Je traiterai de la définition d'une telle distance dans la section suivante.

Les options -ipadx et -ipady changent toutes les deux la taille du widget avant que le rectangle alloué ne soit calculé. -ipadx ajoute le montant spécifié à gauche et à droite du widget. La largeur totale du widget augmentera donc de (montant x 2). La figure 2.23 montre les effets des options -ipadx et -ipady sur un bouton.

L'autre type de remplissage est effectué entre le bord du widget et celui du rectangle alloué. Il est réalisé avec les options -padx et -pady :

-padx => montant
-pady => montant

L'utilisation de -padx et -pady n'affecte pas la taille du widget mais celle du rectangle alloué. Ces options agissent comme un tampon placé autour du widget, l'empêchant de toucher les autres widgets. La figure 2.24 montre les effets de leur utilisation.

Un bon moyen de se rappeler la différence entre -ipadx/y et -padx/y est que le « i » signifie « intérieur du widget » ou « remplissage interne ».

Vous verrez souvent des options, comme -ipadx et -ipady, nécessitant des valeurs indiquées en unités d'écran (ce que l'on appelle une distance d'écran). Vérifiez toujours la valeur que demande réellement l'option. Une unité d'écran est un nombre suivi de l'unité utilisée (par défaut : le pixel).

Pour utiliser ces désignations, il faut mettre la valeur entre apostrophes (simples ou doubles). Voici quelques exemples :

$bouton->pack( -ipadx => 20 );       # 20 pixels
$bouton->pack( -ipadx => '20' );     # encore 20 pixels
$bouton->pack( -ipadx => "1i" );     # 1 pouce
$bouton->pack( -ipadx => '1m' );     # 1 millimètre
$bouton->pack( -ipadx => 1 );        # 1 pixel
$bouton->pack( -ipadx => "20p" );    # 20 points imprimante

Rappelez-vous que la désignation "p" ne signifie ni « pixel », ni « pouce », mais « point imprimante ». Je vous recommande de toujours utiliser les pixels comme unité de mesure car des écrans différents ont des résolutions différentes ; un écran donné peut afficher un vrai pouce et un autre peut afficher autre chose.

Par défaut, lorsqu’un widget est placé, il l'est dans la région qui l'a créé, mais il est parfois nécessaire de l'afficher dans une autre région. Pour ce faire, on utilise l'option -in :

-in => $autrefenêtre

Celle-ci place le nouveau widget à la fin de la liste de placement d'$autrefenêtre et l'affiche en fonction de cela. Toutes les autres options précisées lors de l'appel à pack s'appliquent quand même.

Quelques méthodes sont utilisées en conjonction avec le gestionnaire d'espace pack. Elles permettent au programmeur d'obtenir des informations sur le widget placé, ou sur le widget parent contenant d'autres widgets.

Pour supprimer un widget d'une fenêtre ou d'un cadre, on utilise la méthode packForget :

$widget->packForget();

PackForget fait comme si le widget disparaissait. Il n'est pas détruit, mais n'est plus géré par pack. Il est supprimé de la liste de placement et, s'il doit être replacé plus tard, il sera mis à la fin de cette liste.

Pour récupérer la liste de toutes les informations sur la configuration de l'emplacement d'un widget placé par pack, on utilise packInfo :

@liste = $widget->packInfo();

Cette liste est une suite de paires option/valeur. La première paire est -in avec la fenêtre contenant le widget (habituellement le parent). Voici un exemple d'informations retournées par packInfoo :

-in MainWindow=HASH(Ox8l8dcf4) -anchor n -expand O -fill none 
-ipadx 0 -ipady 0 -padx 10 -pady 10 -side left

On peut en déduire que nous avons placé notre $widget dans la fenêtre principale plutôt que dans un cadre. Comme la liste est appariée, nous pourrions aisément stocker le résultat de packlnfo dans un hachage et faire référence aux différentes options en utilisant une clé de ce hachage :

%infos_placement = $widget->packInfo;
print "Bord utilisé    : ", $infos_placement{-side}, "\n";

Lorsque l'on place un widget dans une fenêtre, celle-ci (ou le cadre) modifiera elle-même sa taille pour qu'elle convienne au widget. Si vous placez dynamiquement des widgets dans votre fenêtre au cours de l'exécution du programme, la fenêtre semblera sauter de taille en taille. Vous pouvez désactiver ce comportement en utilisant la méthode packPropagate sur le cadre ou le widget de premier niveau :

$widget->packPropagate(0);

Si on lui passe la valeur 0 ou 'off', packPropagate modifie le comportement du widget pour qu'il ne modifie pas sa taille afin de tenir compte de widgets qu'il contient. Lorsqu'une valeur fausse est passée à packPropagate avant que les widgets ne soient placés, le changement automatique de taille n'est pas assuré ; vous ne pouvez donc pas voir les widgets placés dans le parent tant que vous n'avez pas modifié explicitement la taille de ce dernier. Si vous appelez packPropagate après que les widgets ont été placés, votre widget ignorera toutes les modifications de taille venant de ses fils.

On peut déterminer quels sont les widgets contenus dans notre cadre ou fenêtre avec la méthode packSlaves :

@liste = $widgetparent->packSlaves();

packSlaves renvoie une liste ordonnée de tous les widgets ayant été placés dans $widgetparent. Si ce dernier ne contient aucun widget placé par pack, cette méthode renvoie une chaîne (ou une liste) vide.

La liste renvoyée par packSlaves ressemble à celle-ci :

Tk::Button=HASH(0x81b2970) Tk::Button=HASH(0x8116ccc) 
Tk::Button=HASH(0x8lbcdd4)

Chaque élément est une référence à un widget placé par pack et peut être utilisé pour configurer celui-ci. On peut, par exemple, augmenter la taille de chaque widget de 20 pixels dans les deux directions en itérant sur chacun des éléments et en les « plaçant » avec cette nouvelle information. En reprenant notre exemple de « Belle fenêtre » de la figure 2.4, on peut ajouter un bouton qui appellerait packSlaves lorsqu'il est pressé :

#!/usr/bin/perl -w
use Tk;
my $mw = MainWindow->new;
$mw->title("Belle fenêtre");
$mw->Label( -text => "Exemple de fenêtre moins disposée au hasard et obtenue en passant des options à pack" )->pack;
$mw->Button(
    -text    => "Agrandir",
    -command => \&replace_fils
)->pack(
    -side   => 'bottom',
    -anchor => 'center'
);
$mw->Button(
    -text    => "Fin",
    -command => sub { exit; }
)->pack(
    -side   => 'bottom',
    -expand => 1,
    -fill   => 'x'
);
$mw->Checkbutton( -text => "J'aime ça !" )->pack(
    -side   => 'left',
    -expand => 1
);
$mw->Checkbutton( -text => "J'ai horreur de ça !" )->pack(
    -side   => 'left',
    -expand => 1
);
$mw->Checkbutton( -text => "Je m'en moque" )->pack(
    -side   => 'left',
    -expand => 1
);

MainLoop;

sub replace_fils {
    my @fils = $mw->packSlaves;
    foreach (@fils) {
        $_->pack( -ipadx => 20, -ipady => 20 );
    }
}

La figure 2.25 montre la fenêtre qui en résulte.

Voyons ce qui se passe lorsque l'on presse le bouton « Agrandir ». Comme le montre la figure 2.26, tous les widgets sont maintenant replacés avec les paramètres additionnels -ipadx => 20, -ipady => 20. Ces nouvelles options s'ajoutent à celles déjà utilisées lors du précédent placement des widgets. Si une option est répétée, la dernière prend le pas sur les précédentes.

La fenêtre devient subitement énorme ! Des pressions supplémentaires sur le bouton « Agrandir » n'auraient aucun effet sur la fenêtre, car tous les widgets ont déjà -ipadx

et -ipady à 20. Si l'on voulait toujours ajouter 20 aux valeurs d'-ipadx et -ipady, il faudrait récupérer les valeurs actuelles et leur ajouter 20. Voici le code réalisant cela :

sub replace_fils {
    my @fils = $mw->packSlaves;
    foreach (@fils) {
        %infos_placement = $_->packInfo();
        $_->pack(
            -ipadx => 20 + $infos_placement{"-ipadx"},
            -ipady => 20 + $infos_placement{"-ipady"}
        );
    }
}

Nous utilisons packInfo pour récupérer la configuration courante, et nous ajoutons 20 aux valeurs concernées.

Différents caractères spéciaux peuvent servir à modifier la façon dont les widgets sont placés avec grid dans la fenêtre. Chacun d'eux sert de marqueur de place précisant que faire de cette position dans la grille :

"-" (le signe moins)

• Indique à grid que le widget spécifié juste avant ce signe dans la liste devra aussi s'étendre sur cette colonne. Pour s'étendre sur plus d'une colonne, mettez un « - » à chaque position étendant le widget. Un « - » ne peut suivre un« ^ » ou un « x ».

"x"

• Laisse un espace vide à l'endroit où un widget aurait normalement dû être placé.

"^"

• Un widget de la ligne x s'étendra sur les lignes x et x + 1 lorsque ce caractère est situé dans la liste des paramètres de grid pour la ligne s + 1 dans cette position ligne/colonne. Le nombre de caractères "^" doit correspondre au nombre de colonnes sur lesquelles s'étend le widget dans la ligne x. Cela ressemble au fonctionnement de "-", mais en vertical(11).

Les sections suivantes contiennent des exemples illustrant les effets de ces caractères spéciaux.

Le code suivant crée trois rangées de boutons. Les deux premières sont normales et, dans la troisième, le second bouton s'étend sur trois colonnes. Chaque caractère "-" incrémente le nombre de colonnes utilisées par le bouton qui est par défaut, de 1. Par conséquent, la colonne de départ et deux tirets ("-", "-") indiquent qu'il y a trois colonnes à traverser. L'option -sticky est nécessaire pour que le bouton colle aux bords des cellules qu'il traverse. Si cette option avait été omise, le bouton aurait été centré par rapport aux trois cellules traversées.

$mw->Button(
    -text    => "Bouton 1",
    -command => sub {
        exit;
    }
)->grid(
    $mw->Button( -text => "Bouton 2", -command => sub { exit } ),
    $mw->Button( -text => "Bouton 3", -command => sub { exit } ),
    $mw->Button( -text => "Bouton 4", -command => sub { exit } )
);
$mw->Button(
    -text    => "Bouton 5",
    -command => sub {
        exit;
    }
)->grid(
    $mw .->Button( -text => "Bouton 6", -command => sub { exit } ),
    $mw->Button( -text => "Bouton 7", -command => sub { exit } ),
    $mw->Button( -text => "Bouton 8", -command => sub { exit } )
);
$mw->Button(
    -text    => "Bouton 9",
    -command => sub {
        exit;
    }
)->grid( $mw->Button( -text => "Bouton 10", -command => sub { exit } ), -sticky => "nsew" );

La fenêtre résultante est celle de la figure 2.28.

Le caractère "x" signifie « sauter cet espace » et laisser un trou dans la grille. Dans le code qui suit, on a supprimé la ligne qui créait « Bouton 6 » et on l'a remplacée par un "x". La cellule est encore présente, mais elle ne contient aucun widget.

$mw->Button(
    -text    => "Bouton 1",
    -command => sub {
        exit;
    }
)->grid(
    $mw->Button( -text => "Bouton 2", -command => sub { exit } ),
    $mw->Button( -text => "Bouton 3", -command => sub { exit } ),
    $mw->Button( -text => "Bouton 4", -command => sub { exit } )
);

$mw->Button( -text => "Bouton 5", -command => sub { exit; } )->grid(
    "x",
    $mw->Button( _text => "Bouton 7", -command => sub { exit } ),
    $mw->Button( -text => "Bouton 8", -command => sub { exit } )
);

Le résultat apparaît à la figure 2.29.

Les options, autres que celles citées ci-dessous, fonctionnent comme celles de pack :

"-"

• Caractère spécial utilisé dans la liste de widgets de grid. Il augmente la valeur de l'option -colunnspan du widget qui se trouve avant lui dans la liste des widgets.

"x"

• Caractère spécial utilisé dans la liste de widgets de grid. Laisse un espace vide dans la grille.

"^"

• Caractère spécial utilisé dans la liste de widgets de grid. Il augmente la valeur de l'option -rowspan du widget qui se trouve directement au-dessus de lui dans la grille.

-column => n

• Indique la colonne où placer le widget (n ≥ 0).

-row => m

• Indique la ligne où placer le widget (m ≥ 0).

-columnspan => n

• Indique le nombre de colonnes à occuper par le widget à partir de -column.

-rowspan => m

• Indique le nombre de lignes à occuper par le widget à partir de -row.

-sticky => chaîne

• La chaîne contient les caractères n (« nord »), s (« sud »), e (« est ») ou w (« ouest ») Le widget collera à ces bords

-in => $autrefenetre

• Indique que le widget sera placé par grid dans $autrefenetre au lieu de l'être dans son parent.

-ipadx => montant

• $widget s'agrandit de 2 x montant dans la direction x.

-ipady => montant

• $widget s'agrandit de 2 x montant dans la direction y.

-padx => montant

• Un espace tampon, égal à montant, est placé à gauche et à droite du widget.

-pady => montant

• Un espace tampon, égal à montant, est placé au-dessus et en dessous du widget.

Plutôt que de laisser grid faire des suppositions, il est parfois nécessaire de préciser explicitement la ligne et la colonne dans lesquelles placer le widget. Les options -row et -column sont faites pour ça. Chacune d'elles prend un entier positif comme paramètre :

-column => n, -row => m

Avec ces options, il n'est pas nécessaire de construire ou de placer les widgets dans un ordre logique quelconque (sauf pour votre propre confort lorsque vous rechercherez des erreurs). Vous pouvez placer votre premier widget en colonne 10 et ligne 5, si vous le désirez. Toutes les autres cellules se trouvant aux lignes et colonnes précédentes resteront vides.

Il est également possible de préciser explicitement qu'un ou plusieurs widgets doivent traverser certaines colonnes ou lignes. Pour traverser des colonnes, on utilise l'option -columnspan et, pour traverser des lignes, l'option -rowspan. Toutes les deux prennent en paramètre un entier supérieur ou égal à 1. Cette valeur précise le nombre de lignes ou colonnes à traverser, elle comprend la ligne ou colonne dans laquelle le widget est placé.

Dans cet exemple, on utilise la façon simple de placer des widgets en ne spécifiant pas explicitement les options -row et -column. Remarquez que le second appel à grid s'applique aux deux widgets : en conséquence, l'option -columnspan s'applique aux deux boutons créés ici.

$mw->Button(
    -text    => "Bouton 1",
    -command => sub {
        exit;
    }
)->grid(
    $mw->Button( -text => "Bouton 2", -command => sub { exit } ),
    $mw->Button( -text => "Bouton 3", -command => sub { exit } ),
    $mw->Button( -text => "Bouton 4", -command => sub { exit } ),
    -sticky => "nsew"
);

# Bouton 5 occupera les colonnes 0-1, et Bouton 6 les colonnes 2-3
$mw->Button(
    -text   => "Bouton 5",
    -command => sub {
        exit;
    }
)->grid(
    $mw->Button( -text => "Bouton 6", -command => sub { exit } ),
    -sticky     => "nsew",
    -columnspan => 2
);

La fenêtre obtenue est celle de la figure 2.30.

Cette fenêtre pourrait aussi avoir été créée en utilisant le caractère spécial « - » afin d'indiquer l'extension de colonne de la façon suivante :

$mw->Button(
    -text    => "Bouton 1",
    -command => sub {
        exit;
    }
)->grid(
    $mw->Button( -text => "Bouton 2", -command => sub { exit } ),
    $mw->Button( -text => "Bouton 3", -command => sub { exit } ),
    $mw->Button( -text => "Bouton 4", -command => sub { exit } ),
    -sticky => "nsew"
);

# Bouton 5 occupera les colonnes 0-1, et Bouton 6 les colonnes 2-3
$mw->Button( -text => "Bouton 5", -command => sub { exit } )
  ->grid( "-", $mw->Button( -text => "Bouton 6", -command => sub { exit } ), "-", -sticky => "nsew" );

L'exemple suivant illustre l'utilisation explicite des options -row et -column en plus de l'option -rowspan :

$mw->Button( -text => "Bouton 1", -command => sub { exit } )
  ->grid( -row => 0, -column => 0, -rowspan => 2, -sticky => 'nsew' );
$mw->Button( -text => "Bouton 2", -command => sub { exit } )
  ->grid( -row => 0, -column => 1 );
$mw->Button( -text => "Bouton 3", -command => sub { exit } )
  ->grid( -row => 0, -column => 2 );
$mw->Button( -text => "Bouton 4", -command => sub { exit } )
  ->grid( -row => 0, -column => 3 );
$mw->Button( -text => "Bouton 5", -command => sub { exit } )
  ->grid( -row => 1, -column => 1 );
$mw->Button( -text => "Bouton 6", -command => sub { exit } )
  ->grid( -row => 1, -column => 2 );
$mw->Button( -text => "Bouton 7", -command => sub { exit } )
  ->grid( -row => 1, -column => 3 );

La fenêtre obtenue est celle de la figure 2.31.

Lorsque l'on utilise pack, il faut utiliser les deux options -fill et -expand pour que le widget change de taille dans son rectangle alloué. grid n'a pas de rectangle alloué à remplir mais une cellule dans la grille. L'utilisation de l'option -sticky avec grid est similaire à l'utilisation de -fill et -expand avec pack.

La valeur associée à -sticky est une chaîne contenant les points cardinaux sur lesquels doit se « coller » le widget. Si le widget doit toujours « coller » au sommet de la cellule, on utilise -sticky => "n". Pour le forcer à remplir complètement la cellule, utilisez -sticky => "nsew". Pour qu'il soit aussi haut que la cellule, mais de largeur normale, utilisez -sticky => "ns". La chaîne peut contenir des virgules et des espaces, ils seront ignorés. Ces deux lignes sont donc équivalentes :

-sticky => "nsew"
-sticky => "n, s, e, w" # Même chose

Si vous utilisez -sticky avec vos widgets, puis que vous modifiez la taille de la fenêtre, vous noterez que leur taille ne varie pas comme vous l'attendez. Cela est dû au fait que le changement de taille des cellules et des widgets qu'elles contiennent est pris en charge par les méthodes gridColumnconfigure et gridRowconfigure, étudiées plus loin dans ce chapitre.

grid accepte aussi les quatre options suivantes : -ipadx, -ipady, -padx et -pady. Elles fonctionnent exactement comme avec pack mais, au lieu de modifier la taille du rectangle alloué, elles changent celle de la cellule dans laquelle se trouve le widget.

Dans l'exemple suivant, les options -ipadx et -ipady s'appliquent à la ligne de boutons supérieure, non à celle du bas. Remarquez comment les boutons 5 à 8 de la figure 2.32 sont aussi plus larges qu'ils ont réellement besoin de l'être. C'est parce que l'on utilise l'option -sticky => "nsew".

$mw->Button( -text => "Bouton1", -command => sub { exit } )->grid(
    $mw->Button( -text => "Bouton 2", -command => sub { exit } ),
    $mw->Button( -text => "Bouton 3", -command => sub { exit } ),
    $mw->Button( -text => "Bouton 4", -command => sub { exit } ),
    -sticky => "nsew",
    -ipadx  => 10,
    -ipady  => 10
);

$mw->Button( -text => "Bouton 5", -command => sub { exit } )->grid(
    $mw->Button( -text => "Bouton 6", -command => sub { exit } ),
    $mw->Button( -text => "Bouton 7", -command => sub { exit } ),
    $mw->Button( -text => "Bouton 8", -command => sub { exit } ),
    -sticky => "nse"
);

Dans l'exemple suivant, les options -padx et -ipady sont appliquées à la rangée supérieure de boutons, pas à celle du bas. Le résultat est donné par la figure 2.33.

$mw->Button( -text => "Bouton 1", -command => sub { exit } )->grid(
    $mw->Button( -text => "Bouton 2",  -command => sub { exit } ),
    $mw->Button( -text => "Bouton 3",  -command => sub { exit } ),
    $mw->Button( -text => "Bouton 4",, -command => sub { exit } ),
    -sticky => "nsew",
    -padx   => 10,
    -pady   => 10
);
$mw->Button( -text => "Bouton 5", -command => sub { exit } )->grid(
    $mw->Button( -text => "Bouton 6", -command => sub { exit } ),
    $mw->Button( -text => "Bouton 7",  -command => sub { exit } ),
    $mw->Button( -text => "Bouton 8",  -command => sub { exit } ),
    -sticky => "nsew"
);

L'option -in fonctionne comme avec pack. $widget sera placé dans $autrefenetre au lieu de l'être dans son parent par défaut. Voici comment utiliser cette option :

-in => $autrefenetre

Comme avec tous les gestionnaires d'espace, certaines méthodes sont associées à grid. Chacune d'elles est appelée via un widget placé sur l'écran à l'aide de grid. Il est parfois nécessaire de modifier les options du groupe de cellules formant notre grille.

On peut contrôler le changement de taille et la taille minimale d'une cellule avec les méthodes gridColumnconfigure et gridRowconfigure. Chacune d'elles prend un numéro de colonne ou de ligne comme premier paramètre et, éventuellement, d'autres paramètres modifiant la configuration de cette colonne ou ligne.

gridColumnconfigure et gridRowconfigure fonctionnent presque comme la méthode configure utilisée sur les widgets. À la différence de cette dernière, cependant, les options utilisables avec gridColumnconfigure et gridRowconfigure ne peuvent être utilisées avec la méthode grid. Les options possibles pour ces deux méthodes sont -weïght, -minsize et -pad.

Si vous ne passez qu'un numéro de ligne ou de colonne en paramètre, ces méthodes renvoient un tableau contenant les options courantes et leurs valeurs pour la méthode.

@config_co1onne = $mw->gridColumnconfigure(0);
@config_ligne = $mw->gridRowconfigure(0);

Dans l'exemple précédent, on récupère les valeurs des options de la première ligne et de la première colonne. Les résultats obtenus en utilisant les valeurs par défaut ressembleraient à ceci :

-minsize 0 -pad 0 -weight 0
-minsize 0 -pad 0 -weight 0

On peut récupérer la valeur d'une seule des options en précisant cette option en deuxième paramètre :

print $mw->gridColumnconfigure(0, -weight), "\n"; 
print $mw->gridRowconfigure(0, -weight), "\n";

Et les résultats seraient :

0
0

Pour changer la valeur d'une option, spécifiez-la avec la valeur que vous voulez lui associer ; par exemple :

$mw->gridColumnconfigure( 0, -weight => 1 );
$mw->gridRowconfigure( 0, -weight => 1 );

Vous pouvez également fournir plusieurs options dans le même appel :

$mw->gridColumnconfigure( 0, -weight => 1, -pad => 10 );
$mw->gridRowconfigure( 0, -weight => 1, -pad => 10 );

Maintenant que nous savons comment appeler gridColumnconfigure et gridRowconfigure, nous devons nous intéresser à ce que font les trois options de ces méthodes.

L'option -weight permet de préciser l'espace qui sera alloué à cette colonne ou à cette ligne lorsque la fenêtre est divisée en cellules. Rappelez-vous qu'il faut utiliser -sticky => "nsew" dans votre appel à grid si vous voulez que le widget change de taille en même temps que la cellule. La valeur par défaut de -weight. est 0, qui indique que la largeur de la colonne ou la hauteur de la ligne dépendront du widget le plus grand de la colonne ou de la ligne. Chaque valeur de -weight est en relation avec les autres -weight des lignes et colonnes.

Si une colonne ou une ligne a une option -weight valant 2, elle est deux fois de la taille d'une colonne ou d'une ligne ayant une valeur de 1 pour cette option. Les colonnes ou lignes ayant l'option -weight à 0 n'auront pas leur taille modifiée. Si vous voulez que tous vos widgets changent de taille en même temps que la fenêtre, ajoutez ceci à votre code avant d'appeler MainLoop :

( $colonnes, $lignes ) = $mw->gridSize();
for ( $i = 0 ; $i < $colonnes ; $i++ ) {
    $mw->gridColumnconfigure( $i, -weight => 1 );
}
for ( $i = 0 ; $i < $lignes ; $i++ ) {
    $mw->gridRowconfigure( $i, -weight => 1 );
}

Ce code mettra un -weight de 1 pour chaque ligne et colonne de la grille, quelle que soit sa taille. Bien sûr, cette méthode ne fonctionne que si vous souhaitez mettre la même taille à toutes les lignes et à toutes les colonnes, mais cela vous donne une idée.

Voici un exemple du fonctionnement de l'option -weight (le résultat est donné par la figure 2.34) :

$mw->Button( -text => "Bouton 1", -command => sub { exit } )->grid(
    $mw->Button( -text => "Bouton 2", -command => sub { exit } ),
    $mw->Button( -text => "Bouton 3", -command => sub { exit } ),
    $mw->Button( -text => "Bouton 4", -command => sub { exit } ),
    -sticky => "nsew"
);
$mw->Button( -text => "Bouton 5", -command => sub { exit } )->grid(
    "x",
    $mw->Button( -text => "Bouton 7", -command => sub { exit } ),
    $mw->Button( -text => "Bouton 8", -command => sub { exit } ),
    -sticky => "nsew"
);
$mw->gridColumnconfigure( 1, -weight => 1 );
$mw->gridRowconfigure( 1, -weight => 1 );

En donnant à la ligne et à la colonne 1 un poids de 1, (alors que toutes les autres lignes et colonnes ont un poids de 0), celles-ci récupèrent tout l'espace supplémentaire rendu disponible par une augmentation de la taille de la fenêtre. Notez que les colonnes 0, 2 et 3 n'ont que la largeur suffisante pour afficher les boutons et leur texte, mais que la colonne 1 a rempli l'espace supplémentaire. Le même effet a lieu pour la ligne 0, qui a un poids de 0, et la ligne 1, qui a un poids de 1 (la fenêtre a été agrandie pour mettre en évidence les effets de -weight).

L'option -minsize permet d'indiquer la largeur minimale d'une colonne ou la hauteur minimale d'une ligne. Sa valeur doit être une distance d'écran. Dans l'exemple qui suit,

la taille minimale des cellules de la ligne 0 et de celles de la colonne 0 est fixée à 10 pixels

$mw->gridColumnconfigure(0, -minsize => 10);
$mw->gridRowconfigure(0, -minsize => 10);

Si la colonne ou la ligne occupait théoriquement moins de 10 pixels, elle aura en fait au moins cette taille.

On peut ajouter des espaces de remplissage (padding) autour du widget, ainsi qu'au widget lui-même en utilisant les options -padx/y et -ipadx/y. Vous pouvez aussi en ajouter en utilisant l'option -pad avec les méthodes gridColumnconfigure et gridRowconfigure. Le remplissage est ajouté autour du widget, pas au widget lui-même. Lorsque vous appelez gridColumnconfigure, l'option -pad ajoutera des espaces à gauche et à droite du widget. L'appel de gridRowconfigure avec -pad ajoutera des espaces au-dessus et en dessous du widget. Voici deux exemples :

$mw->gridColumnconfigure( 0, -pad => 10 );
$mw->gridRowconfigure( 0, -pad => 10 );

La méthode gridBbox permet de récupérer les dimensions d'une cellule :

($offset_x, $offset_y, $largeur, $hauteur) = $cellule->gridBbox(0, 2);

Cet exemple récupère la boîte de dimensionnement de la cellule située à la colonne 0, ligne 2. Toutes les valeurs renvoyées sont exprimées en pixels. La boîte de dimensionnement modifiera sa taille en même temps que celle de la fenêtre. Les quatre valeurs renvoyées représentent le décalage sur l'axe des x, le décalage sur l'axe des y, la largeur de la cellule et sa hauteur (les décalages sont relatifs à la fenêtre ou au cadre dans lequel le widget est placé).

Tout comme packForget, gridForget met le(s) widget(s) hors de vue. Cela peut, ou ne pas, forcer la fenêtre à changer de taille ; cela dépend de la taille du widget et de l'endroit où il se trouvait dans la fenêtre. Voici quelques exemples :

$mw->gridForget();                # Rien ne se passe
$widget->gridForget();            # $widget disparaît
$widget->gridForget($widget1);    # $widget et $widget1 disparaissent
$widget->gridForget( $w1, $w3 );  # $widget, $w1 et $w3 disparaissent

Les widgets disparaissent de la fenêtre, mais les cellules qu'ils occupaient continuent d'exister.

La méthode gridlnfo renvoie des informations sur $widget sous la forme d'une liste. Tout comme packInfo, les deux premiers éléments indiquent où a été placé le widget :

@liste = $widget->gridlnfo();

Voici un exemple de résultats produits par gridInfo :

-in Tk::Frame=HASH(0x81abc44) -column 0 -row 0 -columnspan 1 
-rowspan 2 -ipadx 0 -ipady 0 -padx 0 -pady 0 -sticky nesw

La méthode gridLocation renvoie la colonne et la ligne du widget le plus près des coordonnées (x, y) spécifiées :

($colonne, $ligne) = $mw->gridLocation($x, $y)

$x et $y sont exprimés en unités d'écran relatives à la fenêtre maître ($mw, dans nos exemples). La valeur -1 est renvoyée pour les emplacements au-dessous ou à gauche de la grille.

Lorsqu'on lui passe les paramètres (0, 0), gridLocation retourne : 0 0 qui indique la cellule en colonne 0 et ligne 0.

Il existe une méthode gridPropagate qui ressemble à packPropagate :

$mw->gridPropagate( 0 );

Lorsqu'on lui passe une valeur fausse, gridPropagate désactive la propagation d'espace, ce qui signifie que les informations de taille ne sont pas remontées au parent de $mw. Par défaut, la propagation est activée. Sans paramètre, gridPropagate renvoie sa valeur courante.

Pour savoir la taille que la grille a atteinte après y avoir placé de nombreux widgets, on peut utiliser la méthode gridSize qui renvoie le nombre de colonnes et de lignes de la grille :

($colonnes, $lignes) = $mw->gridSize();

La liste obtenue contient le nombre de colonnes puis de lignes. Dans beaucoup des exemples précédents, nous avions une taille de grille de 4 colonnes par 2 lignes.

($colonnes, $lignes) = $fenetre->gridSize();

Il n'est pas nécessaire qu'un widget soit placé dans une colonne/ligne pour que cette paire soit considérée comme une combinaison colonne/ligne correcte. Si l'on place un widget en colonne 4 et ligne 5 en utilisant -row => 5, -column => 4 et que le seul autre widget se trouve en colonne 0 et ligne 0, gridSize renverra 5 et 6.

Il y a deux moyens de trouver quels sont les widgets qui ont été placés avec grid dans une fenêtre ou dans un cadre. On utilise gridSlaves sans paramètre pour obtenir une liste complète ou bien l'on donne une ligne et une colonne. Voici des exemples de ces deux façons de faire :

@esclaves = $mw->gridSlaves(); 
print "@esclaves\n";

Ce code afficherait quelque chose comme :

Tk::Button=HASH(0x81b6fb8) Tk::Button=HASH(0x81ba454)
Tk::Button=HASH(0x81ba4cc) Tk::Button=HASH(0x81ba538)
Tk::Button=HASH(0x81ba6dc) Tk::Button=HASH(0x81ba748)

Nous aurions pu spécifier le widget de la colonne 0, ligne 0 :

$widget = $mw->gridSlaves( -row => 0, -column => 0 );
print "$widget\n";
# Cela afficherait : Tk::Button=HASH(0x81b6fb8)

Si l'on ne précise que l'option -row, on obtient une liste ne contenant que les widgets de cette ligne. La même chose se passe si l'on ne spécifie que l'option -column : la liste ne contiendra que les widgets de cette colonne.

-anchor => 'n' | 'ne' | 'e' | 'se' 1 's' | 'sw' | 'w' | 'nw' | 'center'

• Configure la position dans le widget qui sera placée aux coordonnées précisées.

-bordermode => 'inside' | 'outside' | 'ignore'

• Détermine si la partie frontière du widget sera incluse ou non dans le système de coordonnées.

-height => montant

• Configure la hauteur absolue du widget.

-in => $fenetre

• Indique que le widget fils sera placé dans $fenetre au lieu du parent qui l'a créé. Toutes les coordonnées ou tailles relatives font quand même référence au parent.

-relheight => ratio

• Indique que la hauteur du widget a un rapport de ratio avec celle du widget parent.

-relwidth => ratio

• Indique que la largeur du widget a un rapport de ratio avec celle du widget parent.

-relx => xratio

• Indique que le widget sera déplacé de xratio, relativement à son widget parent.

-rely => yratio

• Indique que le widget sera déplacé de yratio, relativement à son widget parent.

-width => montant

• Indique que la largeur du widget sera de montant.

-x => x

• Indique que le widget sera placé en z. z est une distance d'écran.

-y => y

• Indique que le widget sera placé en y. y est une distance d'écran.

La fenêtre (ou le cadre) parent a un système de coordonnées standard où 0,0 représente le coin supérieur gauche. Les valeurs x augmentent vers la droite, tandis que les valeurs y augmentent vers le bas. C'est représenté par la figure 2.35.

On utilise les options -x et -y pour utiliser des coordonnées absolues afin de préciser l'emplacement du widget :

-x => x, -y => y

Les valeurs acceptées pour x et y sont des distances d'écran (par exemple, 5, qui est exprimé en pixels). Ces coordonnées seront celles du point d'ancrage (contrôlé par -anchor) du widget. L'ancrage par défaut est "nw", le coin supérieur gauche du widget.

Une autre différence majeure entre place et les autres gestionnaires d'espace est que l'appel de place nécessite au moins deux paramètres. Il n'y a pas de valeurs par défaut pour les options -x et -y et vous obtiendrez une erreur si vous essayez d'appeler place sans paramètre (en faisant, par exemple, $widget->place()).

L'exemple le plus simple de l'utilisation de -x et -y consiste à placer un widget aux coordonnées 0,0 :

$mw->Button( -text => "Fin", -command => sub { exit } )->place( -x => 0, -y => 0 );

Comme l'on pourrait s'y attendre, le widget se place dans le coin supérieur gauche de la fenêtre, ainsi que le montre la figure 2.36. Peu importe la taille de la fenêtre : notre widget restera positionné en 0,0. Même lorsque la fenêtre prend la plus petite taille possible, le widget ne bouge pas.

Voici un exemple d'utilisation de -x et -y pour créer des widgets qui se chevauchent (figure 2.37)

$mw->Button(
    -text    => "Fin",
    -command => sub { exit }
)->place( -x => 10, -y => 10 );
$mw->Button(
    -text    => "Fin",
    -command => sub { exit }
)->place( -x => 20, -y => 20 );

Avec place, il existe un autre système de coordonnées, défini pour le widget parent, et qui permet un placement relatif dans celui-ci. Ce système de coordonnées est montré par la figure 2.38.

Le coin supérieur gauche a les coordonnées (0.0, 0.0) et le coin inférieur droit, les coordonnées (1.0, 1.0). Le centre de la fenêtre serait donc (0.5, 0.5). Ces coordonnées sont exprimées sous une forme en virgule flottante afin de permettre à place de gérer n'importe quelle taille de fenêtre. Cela permet au widget de rester à sa position (au centre, par exemple), quels que soient les changements de taille de la fenêtre.

Il est permis de spécifier des coordonnées inférieures à 0.0 ou supérieures à 1.0. Cependant, il y a fort à parier que le widget ne sera pas complètement visible dans la fenêtre si vous utilisez des coordonnées en dehors de cet intervalle.

Le code suivant produit le bouton montré à la figure 2.39 :

$bouton = $mw->Button(-text => "Fin", -command => sub { exit }); 
$bouton->place(-relx => 0.5, -rely => 0.5);

Bien que le bouton de la figure 2.39 soit placé au centre de la fenêtre, il semble en être décalé car c'est le coin supérieur gauche du widget, et non son centre, qui a été placé au milieu de la fenêtre. On peut changer ceci en utilisant -anchor, dont je parlerai dans un instant. Si nous changeons la taille de cette fenêtre, le bouton reste quand même au milieu (voir la figure 2.40).

L'exemple suivant crée deux boutons, placés dans la fenêtre à l'aide de coordonnées relatives.

$mw->Button(
    -text    => "Fin",
    -command => sub { exit }
)->place(
    -relx => 0.2,
    -rely => 0.2
);
$mw->Button(
    -text    => "Fin",
    -command => sub { exit }
)->place( -relx > 0.5, -rely => 0.5 );

Quelle que soit la taille de la fenêtre ou l'emplacement des autres widgets, les deux boutons resteront à ces coordonnées relatives (voir la figure 2.41).

La fenêtre gauche de la figure 2.41 a la taille qui lui a été donnée lors de sa création. Celle de droite est cette même fenêtre dont on a modifié la taille pour qu'elle soit bien plus petite. Notez que le second bouton reste au-dessus. C'est parce que l'ordre de la liste des widgets de la fenêtre est conservé ; le second bouton « Fin » (placé en 0.5, 0.5) est dessiné en dernier, il est donc tracé au-dessus de l'autre bouton.

On peut aussi combiner les systèmes de coordonnées absolues et de coordonnées relatives en utilisant les deux dans la liste des paramètres. Le système de coordonnées relatives est le premier pris en compte, puis les valeurs des options -x et -y sont ajoutées à cette position. Les options -relx => 0.5, -x => -10 indiquent de placer le widget 10 pixels à gauche du centre de la fenêtre.

Pensez au widget fils comme à un morceau de papier que vous voudriez mettre sur un tableau de liège (le tableau est le widget parent). Vous utiliseriez une punaise pour maintenir le papier sur le tableau. Vous pouvez placer cette punaise au centre du papier, dans son coin supérieur gauche (« nw »), ou dans le coin inférieur droit (« se »). Le point où la punaise maintiendra le papier au tableau est le point d'ancrage. Le point spécifié par -anchor est « punaisé » aux coordonnées données par -x et -y, ou par -relx, -rely. La valeur par défaut d'-anchor est « nw ». La figure 2.38 montre ces points d'ancrage dans le widget fils.

Il est important de savoir où est le point d'ancrage car cela affectera la présentation du widget dans son parent.

Des instructions de placement quasiment identiques ont été utilisées pour placer le bouton « Fin » dans les fenêtres de la figure 2.42. La différence réside en la modification de l'option -anchor. Le bouton de la fenêtre de gauche a été créé ainsi :

$mw->Button(
    -text    => "Fin",
    -command => sub { exit }
)->place(
    -relx => 0.5,
    -rely => 0.5
);

La fenêtre de droite a utilisé le placement suivant :

$mw->Button(
    -text    => "Fin",
    -command => sub { exit }
)->place(
    -relx   => 0.5,
    -anchor => "center",
    -rely   => 0.5
);

Comme avec pack et grid, les valeurs possibles de -anchor sont : 'n', 'e', 's', 'w', 'center', 'nw', 'sw', 'ne' et 'se'. Cependant, la valeur s'applique maintenant au widget fils plutôt qu'à la position dans le rectangle alloué.

Lorsque l'on utilise place, on peut indiquer la largeur et la hauteur du widget en utilisant l'une de ces trois possibilités :

• autoriser le widget à déterminer sa propre taille ;
• préciser la largeur et/ou la hauteur en mesures absolues ;
• préciser la largeur et/ou la hauteur en mesures relatives (au widget parent).

Pour laisser les widgets déterminer leur propre taille, on ne spécifie aucune option. Les autres solutions impliquent d'utiliser les options -width, -height et -relwidth, -relheight, respectivement.

Les options -width et -height permettent d'indiquer la largeur et la hauteur exactes du widget, exprimées en distances d'écran :

-width => montant, -height => montant

Chaque montant est une distance d'écran (ce terme a été introduit plus haut, avec pack). Le widget gardera ces tailles, même s'il coupe les bords des éléments qu'il contient. Notre bouton apparaît plutôt bizarrement sur l'écran lorsque l'on utilise une largeur de 40 pixels (voir la figure 2.43).

$mw->Button(
    -text    => "Ce bouton provoquera la fin du programme",
    -command => sub { exit }
)->place(
    -x     => 0,
    -y     => 0,
    -width => 40
);

Les deux autres options, -relwidth et -relheight, déterminent la largeur et la hauteur du widget par rapport à celles du widget parent.

-relwidth => ratio, -relheight => ratio

ratio est un nombre en virgule flottante (comme les valeurs utilisées par -relx ou -rely). Une valeur de 1.0 rendra le widget aussi large (ou aussi haut) que son parent. Une valeur de 0.5 le réduira de moitié par rapport à son parent (voir la figure 2.44).

Lorsqu'elles sont utilisées ensemble, les options -width et -relwidth s'ajoutent, c'est aussi le cas de -height et -relheight.

NorSmalement, le contour du widget est utilisé comme frontière de l'espace possible dans la fenêtre, ce qui signifie que tout widget placé avec les systèmes de coordonnées absolues ou relatives sera placé à l'intérieur de ce contour. Ce comportement peut être modifié en utilisant l'option -bordermode.

• -bordermode => 'inside' | 'outside' | 'ignore'

L'utilisation de 'outside' permettra au système de coordonnées d'utiliser aussi l'espace occupé par le contour. 'ignore' fera que le système de coordonnées utilisera la zone X Window officielle. Cependant, cette option est peu utile, ainsi que vous pouvez vous en rendre compte en visualisant les différences induites par ces trois valeurs dans l'exemple de la figure 2.45.

Si l'on y regarde de très près (prenez votre loupe), on peut constater que la version utilisant "outside" est plus haute et plus large de deux pixels que la version utilisant "inside". Cela est dû à mon gestionnaire de fenêtre (fvwm) : mes contours ont une largeur de deux pixels.

Les méthodes associées à place sont simples et ne permettent pas de beaucoup manipuler les widgets.

II-C-7-a. Suppression d'un widget ▲

$widget->placeForget();

II-C-7-b. Informations sur les emplacements ▲

@infos = $widget->placeInfo(); 
print "@infos"; 
## Résultats produits (il y a des espaces aux endroits sans valeur) 
-x 0 -relx 0 -y 0 -rely 0 -width -relwidth -height -relheight -anchor nw

II-C-7-c. Énumération des widgets ▲

@widgets = $parent->placeSlaves();