Introduction à Perl/Tk

Interfaces graphiques avec Perl


précédentsommairesuivant

XIII. Widgets de premier niveau

Toute application Perl/Tk contient au moins un widget de premier niveau (toplevel widget). Lorsque l'on appelle la méthode new sur un widget MainWindow, on crée un widget de premier niveau sans même le savoir. Une application doit reposer sur un widget de premier niveau de type MainWindow, mais peut aussi, si nécessaire, contenir d'autres widgets de ce type.

Un widget MainWindow est particulier, car il s'affiche automatiquement lorsque l'on appelle la fonction MainLoop(). Les autres widgets de premier niveau doivent être explicitement affichés par une instruction dans votre code.

Voici deux exemples d'utilisation de ce type de widget :

  • afficher une fenêtre d'informations, munie d'un bouton « Fermer »(36) (voir le premier exemple de la section suivante) ;
  • déclencher la récupération de données par une action de l'utilisateur (appui sur un bouton, par exemple).

Tous les widgets de premier niveau ont le même comportement et leur aspect correspond aux conventions du système sous lequel l'application s'exécute. Chacun d'eux peut contenir d'autres widgets et/ou plusieurs groupes de widgets (ils peuvent, par exemple, être regroupés dans un cadre).

La suite de ce chapitre traitera de l'utilisation des widgets de ce type et des options permettant de modifier leur comportement.

XIII-A. Création d'un widget de premier niveau

La méthode Toplevel, appelée sur le widget parent, permet de créer un widget de premier niveau, habituellement un MainWindow (vous savez déjà que, pour créer une fenêtre principale, il faut écrire MainWindow->new()). L'élément renvoyé est une référence au widget ainsi créé ; elle vous permet de le configurer, de lui appliquer des méthodes et d'y placer des éléments. Voici un exemple simple :

 
Sélectionnez
use Tk;
$mw = MainWindow->new;
$mw->title("Fenêtre principale");
$mw->Button(
    -text    => "Premier niveau",
    -command => \&premier_niveau
)->pack();

MainLoop;

sub premier_niveau {
    if ( !Exists($pn1) ) {
        $pn1 = $mw->Toplevel();
        $pn1->title("Premier niveau");
        $pn1->Button(
            -text    => "Fermer",
            -command => sub { $pn1->withdraw }
        )->pack;
    }
    else {
        $pn1->deiconify();
        $pn1->raise();
    }
}

Lorsqu'on lance ce programme, et que l'on presse le bouton « Premier niveau » de la fenêtre principale, le widget de premier niveau est créé (si nécessaire) et affiché. Presser le bouton « Fermer » rend le widget invisible. On doit tester l'existence de celui-ci avant de l'afficher car, s'il existe, on ne doit pas le recréer et, s'il n'existe pas, on ne doit pas tenter de l'afficher.

Lorsque le bouton « Fermer » est pressé, le widget de premier niveau est effacé. Il existe encore, mais n'est plus visible ; cela permettra de gagner du temps lorsqu'il faudra le réafficher. La méthode withdraw permet également d'éviter que le widget ne s'affiche tandis qu'on y place d'autres widgets. Il suffit d'utiliser la méthode withdraw, de placer les widgets internes, puis de réafficher le widget de premier niveau à l'aide de deiconify et raise.

Les options suivantes sont utilisables lors de l'appel à Toplevel ou via la méthode configure.

-background => couleur

  • Configure la couleur du fond du widget. Ce fond peut être masqué par les widgets placés dans le widget de premier niveau s'il est entièrement rempli.

-borderwidth => montant

  • Fixe la largeur du contour du widget. Par défaut, elle vaut 0.

-class => nom_classe

  • Précise le nom de la classe utilisée avec la base de données des options de ce widget.

-colormap => "new" | $fenetre

  • Indique si le widget doit utiliser une nouvelle palette de couleurs, ou partager celle d'un autre widget de l'application. Par défaut, cette option est indéfinie.

-container => 0 | 1

  • Ne fonctionne qu'avec TK8.0. Si cette option est vraie, la fenêtre contiendra une application intégrée (voir l'option -use).

-cursor => nom_curseur

  • Fixe le type de curseur qui sera utilisé lorsque le pointeur de la souris sera au-dessus du widget de premier niveau.

-height => montant

  • Précise la hauteur du widget.

-highlightbackground => couleur

  • Indique la couleur du rectangle entourant le widget lorsqu'il ne détient pas le focus clavier.

-highlightcolor => couleur

  • Indique la couleur du rectangle entourant le widget lorsqu'il détient le focus clavier.

-highlightthickness => montant

  • Fixe l'épaisseur du rectangle de focus. Par défaut, cette option vaut 0.

-menu => $menu

  • Cette option n'existe qu'avec Tk8.0. Elle indique que le widget de premier niveau utilisera le menu $menu et que celui-ci sera placé en haut de la fenêtre.

-relief => 'flat' | 'groove' | 'raised' | 'ridge' | 'sunken' | 'solid'

  • Modifie l'apparence du contour du widget. La valeur par défaut est 'flat'.

-screen => nom_écran

  • Fixe l'écran sur lequel placer le widget. La valeur de cette option ne peut être modifiée par la méthode configure.

-takefocus => 0 | 1 | undef

  • Précise si le widget de premier niveau pourra recevoir le focus clavier. Sa valeur par défaut, 0, indique qu'il ne le peut pas.

-use => $id_fenetre

  • Cette option n'existe que pour Tk8.0. $id_fenetre doit être une chaîne représentant l'identificateur, exprimé en hexadécimal, de la fenêtre à intégrer dans le widget de premier niveau. Pour utiliser cette option, -container doit valoir 1.

-visual => "type #"

  • Avec le système X Window, cette option permet de modifier le nombre de couleurs disponibles pour l'application. Elle est sans effet avec les systèmes Win32.

-width => montant

  • Fixe la largeur initiale du widget.

XIII-B. Méthodes des widgets de premier niveau

Les sections suivantes énumèrent et détaillent les méthodes des widgets de premier niveau (il est important de noter que toutes ces méthodes s'appliquent aussi au widget MainWindow, qui n'est qu'un widget de premier niveau particulier). Nous n'avons guère rencontré ces méthodes jusqu'à présent, car les widgets de premier niveau sont différents de ceux dont nous avons déjà traité. Rappelez-vous également que la plupart de ces méthodes ont été conçues pour être utilisées dans un environnement de fenêtrage Unix, et que certaines d'entre elles seront considérées comme étant « sans effet sur un système Win32 ». Un grand nombre de ces méthodes n'ont pas grand intérêt pour les applications Perl/Tk ordinaires, mais nous les décrirons par souci d'exhaustivité.

Plusieurs d'entre elles modifient les propriétés du gestionnaire de fenêtres, souvent décrites par des constantes comme WM_PROPRIETE_PROP. Ces propriétés sont traditionnellement associées au système X Window, mais certaines s'appliquent également aux systèmes Win32. Une documentation de méthode n'indiquera rien sur le système lorsqu'elle fonctionnera partout : si elle ne s'applique qu'à l'un ou l'autre (ou ne fonctionne qu'imparfaitement sur un système), cela sera explicitement indiqué.

XIII-B-1. Configuration d'un widget de premier niveau

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.

XIII-B-2. Donner une taille à un widget de premier niveau

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 :

 
Sélectionnez
^=?(\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 :

 
Sélectionnez
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 :

 
Sélectionnez
$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 :

 
Sélectionnez
$premier_niveau->geometry("");

XIII-B-3. Taille maximale

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 :

 
Sélectionnez
$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.

XIII-B-4. Taille minimale

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 :

 
Sélectionnez
$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.

XIII-B-5. Limitation des changements de taille

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

 
Sélectionnez
$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.

XIII-B-6. Utilisation de contraintes sur la taille

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

 
Sélectionnez
$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 :

 
Sélectionnez
($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 :

 
Sélectionnez
($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.

XIII-B-7. Configuration du titre

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

 
Sélectionnez
$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.

XIII-B-8. Affichage d'un widget de premier niveau

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 :

 
Sélectionnez
$premier_niveau->raise();

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

 
Sélectionnez
$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.

XIII-B-9. Effacement d'un widget de premier niveau

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 :

 
Sélectionnez
$premier_niveau->withdraw();

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

XIII-B-10. Mettre en icône un widget de premier niveau

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

 
Sélectionnez
$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.

XIII-B-11. Spécification du bitmap de l'icône

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 :

 
Sélectionnez
$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.

XIII-B-12. Utilisation d'un masque d'icône

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 :

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

XIII-B-13. Configuration du nom de l'icône

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 :

 
Sélectionnez
$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.

XIII-B-14. Configuration de la position de l'icône

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 :

 
Sélectionnez
($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.

XIII-B-15. Utilisation d'une fenêtre à la place d'une icône

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.

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

XIII-B-16. État d'un widget de premier niveau

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

 
Sélectionnez
$etat = $premier_niveau->state();

XIII-B-17. Configuration de la machine cliente

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

 
Sélectionnez
$premier_niveau->client("nom");

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

 
Sélectionnez
$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.

XIII-B-18. Propriétés d'une fenêtre

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 :

 
Sélectionnez
$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.

XIII-B-19. Définition de la palette de couleurs

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 :

 
Sélectionnez
@list = $premier_niveau->colormapwindows();

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

 
Sélectionnez
$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.

XIII-B-20. La propriété commande

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 :

 
Sélectionnez
$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 :

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

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

 
Sélectionnez
$premier_niveau->command("");

XIII-B-21. Mode de gestion du focus

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 :

 
Sélectionnez
$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.

XIII-B-22. Parent d'un widget de premier niveau

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

 
Sélectionnez
$id = $premier_niveau->frame();

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

XIII-B-23. Maillage de l'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 :

 
Sélectionnez
$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.

XIII-B-24. Devenir le chef d'un groupe

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.

XIII-B-25. Suppression des décors des fenêtres

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 :

 
Sélectionnez
$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) :

 
Sélectionnez
$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.

XIII-B-26. Qui a placé la fenêtre ?

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.

 
Sélectionnez
$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.

XIII-B-27. Qui a modifié sa taille ?

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

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

XIII-B-28. Une fenêtre irréelle

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) :

 
Sélectionnez
$parent = $premier_niveau->transient(); 
$premier_niveau->transient($parent);

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

XIII-C. Résumé

Il est préférable d'utiliser un autre widget de premier niveau plutôt que MainWindow si vous devez mettre plus d'informations que ne peut en contenir une seule fenêtre. Les widgets de premier niveau permettent de regrouper les informations, ce qui est une bonne pratique. Le choix de leur utilisation est une décision de conception qui vous appartient : si votre application comporte trop de fenêtres, l'utilisateur risquerait de s'y perdre et une application bien conçue se satisfera d'une ou deux fenêtres. Le module Tk, par exemple, dispose d'un module Tk::Dialog vous permettant de produire facilement des messages à l'attention de l'utilisateur. Consultez la documentation accompagnant le fichier Dialog.pm pour les détails concernant son utilisation.

XIII-D. Essayez et amusez-vous !

Reprenez l'exemple du chapitre 11 portant sur la gestion d'une liste dynamique des documents et créez un nouveau widget de premier niveau à chaque fois que l'utilisateur clique sur le bouton « Nouveau ». Si vous souhaitez aller encore plus loin, faites en sorte que l'application crée ou charge réellement un fichier.


précédentsommairesuivant
Étudiez Tk::Dialog, il a été conçu pour ce type d'application et utilise un widget de premier niveau.

Vous avez aimé ce tutoriel ? Alors partagez-le en cliquant sur les boutons suivants : Viadeo Twitter Facebook Share on Google+   

  

Licence Creative Commons
Le contenu de cet article est rédigé par Nancy Walsh et est mis à disposition selon les termes de la Licence Creative Commons Attribution - Pas d'Utilisation Commerciale - Pas de Modification 3.0 non transposé.
Les logos Developpez.com, en-tête, pied de page, css, et look & feel de l'article sont Copyright © 2018 Developpez.com.