Introduction à Perl/Tk

Les méthodes cget et configure permettent de configurer et d'obtenir les valeurs des options d'un widget de premier niveau. L'annexe A détaille leur utilisation.

La méthode geometry permet de définir ou d'obtenir une chaîne de placement. Celle-ci précise la taille et l'emplacement d'une fenêtre à l'écran. Ce concept a vu le jour sur les systèmes Unix et, à première vue, une telle chaîne est énigmatique. Voici une expression rationnelle décrivant une chaîne complète :

^=?(\d+x\d+)?([+-]\d+[+-]\d+)?$

Le signe égal peut être omis (et l'est généralement). La première partie de l'expression, (\d+x\d+) correspond à la largeur et la hauteur (dans cet ordre) séparées par le caractère x. Par défaut, ces deux mesures sont exprimées en pixels et en nombre de mailles si la fenêtre est maillée avec la méthode grid décrite plus loin. La dernière partie de l'expression correspond aux coordonnées x et y de l'emplacement de l'écran où sera placé le widget de premier niveau. Ces coordonnées sont toujours exprimées en pixels. Voici quelques exemples de chaînes de placement :

300x300       # largeur et hauteur de 300 pixels 
300x450       # largeur de 300 pixels, hauteur de 450 pixels
300x450+0+0   # largeur de 300, hauteur de 450, 
              # placée dans le coin supérieur gauche 
300x450-0-0   # largeur de 300, hauteur de 450, 
              # placée dans le coin inférieur droit 
300x450+10+10 # largeur de 300, hauteur de 450, 
              # placée à 10 pixels du coin supérieur gauche 
+0+0          # fenêtre de taille 'normale', 
              # placée dans le coin supérieur gauche

Lorsque geometry est appelée sans paramètre, elle renvoie la chaîne de placement courante. On peut également utiliser un paramètre représentant un nouvel emplacement pour modifier celui du widget. Pour configurer immédiatement la taille et la position de la fenêtre, on écrirait :

$mw = MainWindow->new(); 
$mw->geometry("300x450+0+0");

Si l'on ne précise que la largeur et la hauteur, le gestionnaire de fenêtres décidera de l'emplacement du widget. Si l'on ne précise que l'emplacement, la taille de la fenêtre dépendra des widgets qu'elle contient, mais elle sera placée aux coordonnées x et y indiquées.

Si l'on donne à geometry une chaîne vide en paramètre, la fenêtre reprendra sa taille normale :

$premier_niveau->geometry("");

La méthode maxsize permet de limiter la taille maximale d'une fenêtre ; elle attend deux paramètres. L'instruction suivante limite la taille du widget $premier_niveau à une largeur de 300 et à une hauteur de 450 pixels :

$premier_niveau->maxsize(300,450);

Si cette méthode est appelée sans paramètre, elle renvoie une chaîne vide ou une liste de deux éléments représentant la largeur et la hauteur courantes. Si les deux paramètres sont des chaînes vides, la limitation de la taille est annulée.

La taille minimale de la fenêtre peut également être précisée à l'aide de la méthode minsize. La fenêtre sera alors toujours d'une taille au moins égale à celle spécifiée :

$premier_niveau->minsize(100,150);

garantit que la largeur du widget sera toujours au moins égale à 100 pixels, et que sa hauteur minimale est de 150 pixels.

Si cette méthode est appelée sans paramètre, elle renvoie une chaîne vide ou une liste de deux éléments représentant la largeur et la hauteur courantes. Si les deux paramètres sont des chaînes vides, la taille minimale est annulée.

La méthode resizable permet de contrôler la modification de la largeur et/ou de la hauteur d'une fenêtre :

$premier_niveau->resizable(1, 0); 
($modif_largeur, $modif_hauteur) = $premier_niveau->resizable();

Une valeur de 1 signifie que la dimension correspondante est modifiable, 0 indiquera une taille fixe. Sans paramètre, resizable renvoie une liste de deux éléments valant 1 ou 0. Le premier indique si la largeur pourra être modifiée, le second concerne la hauteur. Par défaut, la taille d'une fenêtre est modifiable dans les deux directions.

La méthode aspect permet de forcer la fenêtre à conserver une largeur et une hauteur dans une plage de proportions donnée :

$premier_niveau->aspect( [ numMin, denMin, numMax, denMax ] ) ;

Cette méthode réalise des opérations subtiles et vous ne l'utiliserez probablement jamais. Si vous le faites, essayez différentes valeurs (en commençant par celles de l'exemple ci-dessous) pour obtenir l'effet recherché. Les quatre paramètres, s'ils sont fournis, servent à définir un intervalle de proportions largeur/hauteur pour le widget.

Cet intervalle sera compris entre numMin/denMin et numMax/denMax :

($nMin/$dMin) < largeur/hauteur < ($nMax/$dMax)

Si aucun paramètre n'est fourni, aspect renvoie une chaîne vide (indiquant qu'il n'y a pas de contrainte sur les proportions de la fenêtre) ou un tableau de quatre éléments précisant les contraintes existantes :

($nMin, $dMin, $nMax, $dMax) = $premier_niveau->aspect;

Vous pouvez également utiliser quatre chaînes vides comme paramètres afin d'annuler les restrictions sur les proportions de la fenêtre. Vous constaterez notamment que les effets de l'instruction $premier_niveau->aspect(1,2,3,1) sont subtils.

Le texte situé dans la barre de titre est modifiable par la méthode title :

$premier_niveau->title("Voici le titre");

Si la fenêtre est visible, le nouveau titre apparaîtra immédiatement. Sans paramètre, cette méthode renvoie le titre courant. Dans le cas d'un système X Window, le titre par défaut d'une fenêtre est le nom du programme dont la première lettre est mise en majuscule. Pour Microsoft Windows, le titre par défaut est toujours Toplevel.

La méthode deiconify affiche le widget ou restaure la fenêtre et supprime l'icône immédiatement à condition que la fenêtre ait déjà été affichée une première fois. Si elle a été effacée, l'instruction $premier_niveau->raise() doit également être utilisée afin d'afficher correctement la fenêtre.

Appelée sans paramètre, la méthode raise place le widget de premier niveau au-dessus de toutes les autres fenêtres de l'application :

$premier_niveau->raise();

Elle permet également de placer le widget au-dessus d'un autre widget de premier niveau :

$premier_niveau->raise($autre_premier_niveau);

Il est parfois nécessaire d'utiliser à la fois deiconify et raise pour que la fenêtre apparaisse à l'écran.

Lorsque l'on crée une fenêtre, il est préférable qu'elle reste invisible tant que l'on n'y a

pas placé les widgets. Pour cela, on utilise la méthode withdraw :

$premier_niveau->withdraw();

Si la fenêtre est visible, le gestionnaire de fenêtre l'oubliera jusqu'à ce qu'elle soit désiconifiée.

La méthode iconify met le widget sous forme d'icône :

$premier_niveau->iconify();

Il ne s'agit pas de la même opération que celle réalisée par withdraw ; cette dernière n'affiche pas d'icône sur le bureau.

Avec le système X Window, lorsqu'une application est mise sous forme d'icône, cette dernière est représentée à l'écran par un bitmap. Pour spécifier celui-ci, on utilise la méthode iconbitmap :

$premier_niveau->iconbitmap(); 
$premier_niveau->iconbitmap("bitmap");

Cette méthode prend un bitmap en paramètre, tout comme le fait l'option -bitmap du widget bouton (voir le chapitre 3, Le bouton de base). Si on l'appelle sans paramètre, elle renvoie le bitmap courant ou une chaîne vide. Appelée avec une chaîne vide, elle ôte le bitmap courant.

Sur les systèmes Win32, l'application est représentée dans la barre de tâches par une icône Tk non modifiable et le nom de l'application. L'utilisation de cette méthode avec un tel système est sans effet.

La méthode iconmask permet d'indiquer un masque pour le bitmap de l'icône (rappelez-vous que cela ne fonctionne qu'avec le système X Window). Elle prend comme paramètre un fichier bitmap ou un bitmap prédéfini (voir l'option -bitmap, décrite au chapitre 3). Tout pixel du bitmap de l'icône correspondant à un 0 dans le masque ne sera pas affiché.

L'appel de iconmask sans paramètre renvoie le masque courant ou une chaîne vide si aucun bitmap n'est utilisé. Si le paramètre est une chaîne vide, cette méthode annule le masque :

$masque_courant = $premier_niveau->iconmask(); # obtient le masque 
$premier_niveau->iconmask("nom_bitmap"); # utilise le masque 
$premier_niveau->iconmask(""); # annule le masque

La méthode iconname configure ou renvoie le texte associé à l'icône affichée lorsque l'application est sous cette forme. On peut lui passer une nouvelle chaîne ou une chaîne vide :

$premier_niveau->iconname("nouveau_nom"); 
$nom_courant = $premier_niveau->iconname();

Si l'on ne passe pas de paramètre, iconname renvoie le nom courant de l'icône ou une chaîne vide. On peut interroger et configurer le nom de l'icône sur un système Win32, mais c'est sans effet ; cette méthode n'agit qu'avec X Window.

La méthode iconposition propose au système X Window un emplacement pour l'icône sur le bureau lorsque l'application sera mise sous cette forme :

($x, $y) = $premier_niveau->iconposition();
$premier_niveau->iconposition($x, $y);

Si x et y ne sont pas utilisées, la méthode renvoie une liste ne contenant que deux éléments : les coordonnées x et y courantes. Pour annuler la proposition faite au gestionnaire de fenêtre, on appelle iconposition avec deux chaînes vides pour x et y.

Certains systèmes (pas Win32) permettent d'utiliser un widget (ou une fenêtre) à la place d'un bitmap pour représenter l'icône. On indique le widget à l'aide de la méthode iconwindow. Pour connaître le widget utilisé, il suffit d'appeler la méthode sans paramètre (si aucun widget n'est associé, elle renverra une chaîne vide). Si le paramètre est une chaîne vide, cela annulera l'utilisation d'un widget pour l'icône.

$fenetre_courante = $premier_niveau->iconwindow(); # interroge 
$premier_niveau->iconwindow($fenetre);             # configure 
$premier_niveau->iconwindow("");                   # annule

La méthode state renvoie l'une des trois chaînes suivantes, qui indiquent l'état courant du widget : "normal", "iconic", ou "withdrawn".

$etat = $premier_niveau->state();

La méthode client permet d'initialiser la propriété WM_CLIENT_MACHINE avec la valeur du paramètre qui lui est passé :

$premier_niveau->client("nom");

Pour obtenir le nom courant, il suffit d'écrire :

$nom = $premier_niveau->client();

Si le paramètre de client est une chaîne vide, la valeur courante de WM_CLIENT_MACHINE est effacée.

La méthode protocol contrôle les propriétés de fenêtre WM_DELETE_WINDOW, WM_SAVE_YOURSELF, et WM_TAKE_FOCUS. La fonction de rappel associée à chaque propriété sera appelée lorsque le gestionnaire de fenêtre reconnaîtra l'événement correspondant :

$premier_niveau->protocol ( [ nom_propriété ] [, fct_rappel ] );

La fonction de rappel de la propriété WM_DELETE_WINDOW est invoquée lorsque la fenêtre est détruite par le gestionnaire de fenêtres. Par défaut, Perl/Tk utilise une classique fonction de destruction de la fenêtre. Si vous assignez une autre fonction, celle-ci sera appelée à la place de la fonction par défaut. Pour sauvegarder les données associées à cette fenêtre, faites-le dans la fonction de rappel, qui appellera ensuite $premier_niveau->destroy() afin de copier le comportement par défaut.

Les deux autres propriétés, WM_SAVE_YOURSELF et WM_TAKE_FOCUS, sont beaucoup moins souvent utilisées. WM_TAKE_FOCUS, par exemple, existe sur les systèmes Unix, mais pas sous Win32. La présence de ces propriétés dépend du système de fenêtrage utilisé et, si votre application doit être multiplateforme, ne vous attendez pas à ce qu'elles soient toujours disponibles. Pour savoir si elles le sont, il suffit d'assigner à chacune d'elles une fonction de rappel qui affiche un message, puis de lancer l'application pour vérifier si ces messages sont affichés.

Si vous n'assignez pas de fonction de rappel lors de l'appel à protocol, cette méthode renverra celle qui est affectée à cette propriété (ou une chaîne vide, s'il n'y en a aucune). Pour supprimer la fonction de rappel, il suffit de passer une chaîne vide au lieu d'un nom de fonction. Sans paramètre, cette méthode renvoie une liste de toutes les propriétés ayant des fonctions de rappel qui leur sont assignées.

La méthode colormapwindows affecte la propriété WM_COLORMAP_WINDOWS. Celle-ci sert à indiquer au gestionnaire de fenêtres celles qui utilisent une palette de couleurs privée. Sans paramètre, cette méthode renvoie une liste des fenêtres (par ordre de priorité) qui ont une palette différente de celle de leur parent :

@list = $premier_niveau->colormapwindows();

On peut également lui passer une liste de fenêtres :

$premier_niveau->colormapwindows(@liste);

Si vous n'utilisez pas cette méthode, Perl/Tk s'occupera de tout à votre place, bien que l'ordre des fenêtres puisse être différent.

La méthode command (que l'on ne doit pas confondre avec l'option -command, utilisée avec la plupart des widgets) contrôle la propriété WM_COMMAND. Sans paramètre, cette méthode renvoie une référence à une liste :

$ref_liste = $premier_niveau->command();

Cette liste contient les mots formant la commande utilisée pour lancer l'application. On utilisera ces lignes pour déterminer la commande qui a lancé notre application :

$ref_liste = $mw->command(); 
foreach (@$ref_liste) { 
    print "$_\n"; 
}

La propriété WM_COMMAND est désactivée en utilisant une chaîne vide :

$premier_niveau->command("");

La méthode focusmodel contrôle si le widget de premier niveau abandonnera le focus clavier lorsqu'une autre application ou une autre fenêtre le réclamera :

$premier_niveau->focusmodel( [ "active" | "passive" ] ) ;

La valeur par défaut est « passive », ce qui signifie que le widget abandonnera le focus clavier. Le mode de passage du focus dans votre application dépend entièrement du gestionnaire de fenêtres sous lequel celle-ci s'exécute. Je n'ai constaté aucune différence entre Win32 et X Window.

La méthode frame renvoie une chaîne hexadécimale représentant l'identificateur du parent du widget de premier niveau :

$id = $premier_niveau->frame();

L'instruction $widget->id() permet d'obtenir l'identificateur de n'importe quel widget de votre application.

La méthode grid pose quelques problèmes : rappelez-vous du chapitre 2 où, là aussi, il y avait une méthode grid contrôlant la gestion de l'espace. Pour contourner ce petit problème, on doit appeler cette méthode d'une façon curieuse :

$mw->wm('grid', ... );

Il faut utiliser la méthode wm (qui signifie window manager, gestionnaire de fenêtres) afin d'invoquer grid indirectement.

Cet appel clarifié, nous pouvons détailler ce que fait wm('grid', ...). Lorsque l'on demande à la fenêtre de se mailler, on limite sa taille : celle-ci doit toujours se raccrocher au maillage défini. Rappelons-nous du widget boîte de liste et de l'option -setgrid, étudiés au chapitre 7, Le widget boîte de liste. Lorsque l'on a utilisé -setgrid => 1 sur une liste, on peut écrire @liste = $premier_niveau->wm('grid') afin de connaître les valeurs du maillage. Celles que j'obtiens sur mon système sont 10, 10, 7, 17. Cela signifie que la largeur et la hauteur de base sont de 10 pixels et qu'une maille couvre une zone de 7 pixels de large et de 17 pixels de haut. La taille de la grille et des pas de progression sont modifiables en indiquant les nouvelles valeurs lors de l'appel à wm('grid', ...). On annule ces valeurs de maillage en utilisant des chaînes vides pour chacune des valeurs.

Vous n'utiliserez jamais la méthode group, mais il est préférable de savoir pourquoi. Cette méthode promeut un widget en chef d'un groupe de fenêtres. Utilisez l'instruction $premier_niveau->group($widget) pour chaque widget de premier niveau que vous souhaitez placer dans le groupe de $widget. Si vous ne précisez pas ce dernier, cet appel renverra le chef actuel du groupe de $premier_niveau, ou une chaîne vide si $premier_niveau n'appartient à aucun groupe.

Si le paramètre de group est une chaîne vide, cela annule l'appartenance du widget de premier niveau à ce groupe.

Pour qu'une fenêtre apparaisse sans aucun décor (barre de titre, contour, etc.), on utilise la méthode overrideredirect en lui passant une valeur vraie :

$premier_niveau->overrideredirect(1); # Ôte tous les décors

Soyez tout de même prudent : vous ne pourrez plus déplacer la fenêtre affichée à l'écran et, si vous avez oublié d'y placer un bouton de type « Fin », vous ne pourrez quitter correctement l'application (il faudra donc composer 'Ctrl-C' dans la fenêtre ayant lancé le script afin de tuer son processus).

Cela permet d'afficher une fenêtre temporaire d'accueil – apparaissant pendant le démarrage de votre application. N'oubliez pas d'appeler MainLoop, sinon elle n'apparaîtra pas.

L'appel de overrideredirect sans paramètre renvoie la valeur courante (1 ou 0) :

$val_courante = $premier_niveau->overrideredirect();

Une fois que la fenêtre est affichée, un nouvel appel avec un paramètre valant 0 ne remettra pas le décor en place.

Lorsque le widget de premier niveau est affiché sur la fenêtre, le gestionnaire de fenêtres indique au programme où se placer, ou bien le programme indique au gestionnaire où il veut être. Dans certains cas, c'est l'utilisateur qui place lui-même la fenêtre lorsqu'elle apparaît.

$qui = $premier_niveau->positionfrom(); # "program" ou "user" ? 
$premier_niveau->positionfrom("program"); # Tente de forcer

Sans paramètre, la méthode positionfrom rend compte de ce qui s'est passé. S'il s'agit de "program", d'une chaîne vide ou d'un widget, cela signifie que c'est le gestionnaire de fenêtres ou le programme qui a demandé la position. S'il s'agit de "user", c'est que c'est l'utilisateur qui a fait cette demande.

On force le comportement souhaité en appelant positionfrom avec le paramètre "program" ou "user", mais cela ne fonctionnera que si votre gestionnaire de fenêtres l'accepte.

La méthode sizefrom fait la même chose que positionfrom sauf qu'elle concerne le changement de taille de la fenêtre.

$qui = $premier_niveau->sizefrom(); # "program" ou "user" ? 
$premier_niveau->sizefrom("user"); # Tente de forcer

Une fenêtre transitoire (comme un menu déroulant) n'est pas vraiment une vraie fenêtre. La méthode transcient permet d'indiquer au gestionnaire de fenêtres qu'un widget de premier niveau (un menu déroulant ou une boîte de dialogue, par exemple) est lié à son parent (la fenêtre dans laquelle il s'affiche) :

$parent = $premier_niveau->transient(); 
$premier_niveau->transient($parent);

Sans paramètre, cette méthode renvoie le parent courant ou une chaîne vide.