Introduction à Perl/Tk

Interfaces graphiques avec Perl


précédentsommairesuivant

XVI. Méthodes communes à tous les widgets

Tous les chapitres déjà vus ne traitaient que de widgets spécifiques. Celui-ci s'intéresse aux méthodes communes à tous les widgets : vous ne les utiliserez sûrement pas toutes, mais certaines sont fréquemment utilisées.

La plupart du temps, on utilise une référence vers un widget MainWindow (habituellement nommée $mw dans les exemples de ce livre) afin d'appeler ces méthodes, mais il est également possible de le faire à partir de références à d'autres widgets, comme $bouton, $bouton_radio, etc. Beaucoup de ces méthodes ne font que renvoyer des informations : on ne leur passe pas de paramètre et elles renvoient une valeur.

Nous utiliserons ici la référence générique $widget au lieu d'une référence vers un type particulier ; rappelons-nous que ces méthodes ne sont pas propres à un type spécifique de widget.

XVI-A. Construction d'une généalogie

Les méthodes children, name, parent, toplevel, manager et class s'occupent des ancêtres ou des fils des widgets, ainsi que de leur création.

XVI-A-1. Fils d'un widget

On utilisera la méthode children pour connaître les fils d'un widget (habituellement de premier niveau ou un cadre) :

 
Sélectionnez
@fils = $widget->children();
# par exemple : Tk::Button=HASH(0x85e3a0) Tk::Button=HASH(0x85e4a8)

La liste renvoyée contient des scalaires représentant les fils du widget. Ces références serviront à réaliser certaines opérations par exemple la configuration de la couleur du fond ou la modification de la fonte.

XVI-A-2. Nom d'un widget

Pour connaître le nom sous lequel le widget est connu de son parent, on utilise la méthode name :

 
Sélectionnez
$nom = $widget->name();

Les deux méthodes précédentes peuvent être combinées de la façon suivante :

 
Sélectionnez
@fils = $widget->children();
foreach (@fils) {
    print "Nom :", $_->name(), "";
}

Voici un exemple de ce que cela pourrait produire :

 
Sélectionnez
bouton
bouton1

XVI-A-3. Parent d'un widget

La méthode parent permet d'obtenir une référence au parent du widget :

 
Sélectionnez
$parent = $widget->parent();

XVI-A-4. Premier niveau d'un widget

La méthode toplevel renvoie le widget de premier niveau contenant le widget :

 
Sélectionnez
$chemin = $widget->toplevel();

Le $chemin renvoyé est un nombre (8606484, par exemple) que l'on peut comparer à celui produit par un autre appel à toplevel pour déterminer, par exemple, si deux widgets appartiennent au même widget de premier niveau.

XVI-A-5. Gestionnaire d'espace d'un widget

Afin de connaître le gestionnaire d'espace utilisé pour placer un widget, on utilise la méthode manager :

 
Sélectionnez
$gestionnaire = $widget->manager();

Cet appel renverra une chaîne contenant le nom du gestionnaire d'espace utilisé ; si le widget est de premier niveau, cette chaîne sera "grid", "pack", "place", ou "wm". Cette méthode semble ne pas fonctionner correctement sous Windows 95, mais ne pose pas de problème sous Unix et Windows NT.

XVI-A-6. Classe d'un widget

La méthode class renvoie une liste indiquant la classe du widget. $liste->class(), par exemple, renverra "Listbox" et $menu->class(), "Menu".

XVI-A-7. Identificateur d'un widget

On obtient la chaîne d'identification d'un widget avec la méthode id :

 
Sélectionnez
$id = $widget->id();
print "$id";
# Affiche 0x9c944c

La valeur renvoyée est exprimée en hexadécimal. Cette méthode ne fonctionne pas sous Windows 95.

XVI-A-8. Chemin d'un widget

Le chemin d'accès d'une fenêtre est obtenu en appelant pathname avec l'identificateur renvoyé par la méthode id :

 
Sélectionnez
$chemin = $widget->pathname($id);

Il existe également une méthode PathName :

 
Sélectionnez
$chemin = $mw->PathName();

Celle-ci renvoie le chemin du widget qui l'a appelée. Dans le cas de $mw, par exemple, le résultat serait ".".

XVI-B. Méthodes concernant la couleur

Les méthodes colormapfull, rgb, cells et depth permettent de gérer les couleurs.

XVI-B-1. La palette de couleurs est-elle saturée ?

La méthode colormapfull permet de déterminer si la palette de couleurs du widget est pleine :

 
Sélectionnez
$est_pleine = $widget->colormapfull();

colormapfull renvoie 1 si la palette est pleine, 0 sinon.

XVI-B-2. Nombre de cellules

La méthode cells renvoie le nombre de cellules de la palette de couleurs :

 
Sélectionnez
$nbre = $widget->cells();

Ce nombre indique le nombre de couleurs : 64, par exemple.

XVI-B-3. Profondeur de couleur

La méthode depth permet d'obtenir le nombre de bits par pixel(41) :

 
Sélectionnez
$profondeur = $widget->depth();
# $profondeur contiendra 16, par exemple.

XVI-B-4. Conversion en valeur RGB

La méthode rgb permet de traduire un nom de couleur en valeurs de rouge, de vert et de bleu. On lui passe le nom (l'un de ceux qui ont été traités au chapitre 3), et elle renvoie une liste de trois éléments représentant, respectivement, les composantes rouge, vert et bleu.

 
Sélectionnez
($rouge, $vert, $bleu) = $widget->rgb("SlateGrey");

Les variables $rouge, $vert et $bleu contiennent maintenant un entier compris entre 0 et 255 (dans cet exemple : 112, 128 et 144).

XVI-B-5. Configuration des couleurs

La méthode setPalette permet à votre application d'utiliser automatiquement des couleurs en fonction d'une couleur donnée.

 
Sélectionnez
$widget->setPalette(couleur);

La couleur de fond de $widget sera de la couleur spécifiée et les couleurs de tous les autres widgets seront calculées à partir de celle-ci. Ainsi, si le contour d'un bouton est plus clair que le fond, il apparaîtra dans une teinte plus claire que la couleur choisie. Cette méthode affecte l'application entière, même si on l'a appelée sur un widget plutôt que sur une fenêtre.

Les couleurs de certaines options sont configurables ; il suffit de fournir le nom de l'option, puis la couleur que l'on souhaite lui associer. Le fragment de code suivant, par exemple, met en rouge l'avant-plan de l'application et en bleu le fond :

 
Sélectionnez
$b->setPalette("background" => "blue", "foreground" => "red");

XVI-B-6. Configuration de couleur prédéfinie

La méthode bisque utilise la configuration de couleur « bisque" pour toute l'application. L'appel $widget->bisque() est équivalent à $widget->setPalette("bisque").

XVI-C. Bases de données des options

Le système X Window utilise un fichier .Xdefaults, situé dans le répertoire personnel de l'utilisateur. Ce fichier contient des informations sur la configuration des applications X, comme les couleurs et les fontes utilisées et est entièrement modifiable par l'utilisateur. On peut créer le même type de fichier pour les systèmes Win32 et l'utiliser si nécessaire.

Habituellement, les lignes de ce fichier ressemblent à celles-ci :

 
Sélectionnez
screen*background: yellow
screen.button.foreground: green
screen*font: {Arial} 24 {normal}

Le premier élément d'une ligne est le nom de l'application, sauf si les options ne concernent que celle-ci. L'exemple ci-dessus concerne une application contenue dans un fichier nommé screen, c'est pourquoi ce nom est le premier mot-clé de chaque ligne. Le second élément (s'il est présent) est un type ou un nom de widget (on attribue un nom à n'importe quel widget en utilisant l'option -name lors de sa création). Le troisième mot-clé est la « classe » pour laquelle on veut fixer une valeur par défaut. Cette valeur peut être attribuée à toute option du widget. L'annexe A vous permettra de trouver la classe associée à chaque type de widget.

Pour lire ce fichier, on appelle la méthode optionReadfile, en lui passant son emplacement en paramètre ("options_couleur", "C:Xdefaults" ou ".Xdefaults", par exemple) :

 
Sélectionnez
$widget->optionReadfile("mon_fic");

Assurez-vous d'ajouter un caractère retour chariot à la fin de la dernière ligne de ce fichier, sous peine de provoquer une erreur affichant un message comme « missing newline on line 2 at C:\PERL\lib\site\Tk\Submethods.pm line 16 »(42) . Celui-ci n'a pas grand sens, excepté le premier numéro de ligne qui correspond au nombre de lignes que l'on a tenté de lire dans le fichier d'options. Si l'on utilise

 
Sélectionnez
$widget->option("readfile"…)

pour appeler cette méthode, le message sera plus explicite.

Le deuxième paramètre de optionReadfile est facultatif : il permet d'indiquer une priorité valant "widgetDefault", "startupFile", "userDefault", ou "interactive". La priorité la plus haute, qui est également celle par défaut, est "interactive".

 
Sélectionnez
$widget->optionReadfile("mon_fic", "widgetDefault");

On ajoute une option pendant l'exécution du programme à l'aide de la méthode optionAdd (que l'on ait, ou non, utilisé optionReadfile).

 
Sélectionnez
$widget->optionAdd(motif => valeur);

On peut, par exemple, modifier la fonte du programme entier à l'aide de l'instruction suivante :

 
Sélectionnez
$widget->optionAdd("screen*font", "Arial 24 normal");

La méthode optionClear réinitialise toutes les options courantes et relit le fichier (ou récupère celles-ci en interrogeant le gestionnaire de ressources) :

 
Sélectionnez
$widget->optionClear();

La méthode optionGet permet de connaître la valeur courante associée à un nom et à une classe :

 
Sélectionnez
$widget->optionGet(nom, classe);

XVI-D. Le nom de l'application

Le nom de l'application utilisé dans le fichier d'options étudié ci-dessus est, par défaut, le nom du fichier de script. La méthode appname permet de modifier le nom de l'application :

 
Sélectionnez
$mw->appname("nouveau_nom");

Sans paramètre, cette méthode renvoie le nom courant de l'application :

 
Sélectionnez
$name = $mw->appname();

XVI-E. Existence d'un widget

Pour savoir si un widget a été créé, il suffit d'utiliser l'appel Exists($widget) :

 
Sélectionnez
if (Exists($widget)) {}

Notez le « E » majuscule de cette méthode. Celle-ci est différente de la fonction exists de Perl : attention à ne pas les confondre !

XVI-F. Le widget est-il affiché ?

La méthode ismapped permet de savoir si le widget a été affiché à l'écran :

 
Sélectionnez
if ($widget->ismapped()) {
    # faire quelque chose
} else {
    # affiche le widget
}

Cette méthode renvoie 1 si le widget est actuellement affiché à l'écran, 0 sinon.

XVI-G. Conversion des distances d'écran

Si vous préférez utiliser des pouces comme unité de distance d'écran, mais que vous souhaitez afficher en comptant en pixels, utilisez la méthode pixels pour convertir n'importe quelle distance d'écran en valeur exprimée en pixels :

 
Sélectionnez
$pixels = $widget->pixels("2i"); # 2 pouces en pixels ?
$pixels = $widget->pixels("2m"); # 2 millimètres en pixels ?

La méthode pixels arrondit la valeur au pixel entier le plus proche. Pour obtenir un résultat fractionnaire, utilisez fpixels :

 
Sélectionnez
$pixels = $widget->fpixels("2i"); # 2 pouces en pixels ?
$pixels = $widget->fpixels("2m"); # 2 millimètres en pixels ?

XVI-H. Taille d'un widget

Les méthodes suivantes permettent, par divers moyens, de connaître les différentes composantes de la taille d'un widget.

XVI-H-1. Géométrie d'un widget

La méthode geometry renvoie la chaîne de géométrie du widget sous la forme largeur x hauteur+x+y.

 
Sélectionnez
$geom = $widget->geometry();

Cette chaîne a déjà été détaillée au chapitre 13. Les valeurs sont exprimées en pixels.

XVI-H-2. Hauteur demandée

La méthode reqheight renvoie la hauteur du widget :

 
Sélectionnez
$hauteur = $widget->reqheight();

C'est le widget lui-même qui détermine sa hauteur correcte.

XVI-H-3. Largeur demandée

La méthode reqwidth renvoie la largeur du widget :

 
Sélectionnez
$largeur = $widget->reqwidth();

XVI-H-4. Largeur réelle

La méthode width renvoie la largeur courante du widget, tel qu'il est affiché :

 
Sélectionnez
$largeur_courante = $widget->width();

Lorsque le widget est créé, width retournera 1 jusqu'à ce que l'application ait fini de tout tracer. Elle renverra ensuite la largeur réelle du widget.

XVI-H-5. Hauteur réelle

La méthode height renvoie la hauteur courante du widget :

 
Sélectionnez
$hauteur_courante = $widget->height();

Tout comme width, la méthode height renvoie 1 lorsque le widget est créé. On utilisera les méthodes update ou afterIdle pour forcer la suite des événements et on appellera ensuite height ou width pour obtenir les valeurs finales.

XVI-I. Position d'un widget

Toutes les méthodes de cette section gèrent la position d'un widget.

XVI-I-1. Position relative à la fenêtre racine

La méthode containing permet de savoir quel est le widget se trouvant aux coordonnées $x et $y :

 
Sélectionnez
$qui = $widget->containing($x, $y);

$x et $y doivent être exprimées relativement à la fenêtre racine (ou au bureau, sur les systèmes Win32). La méthode renverra une chaîne vide s'il n'y a pas de widget à ces coordonnées. Si plusieurs s'y trouvent, c'est celui du dessus qui sera renvoyé.

XVI-I-2. Coordonnées relatives au parent

Les méthodes x et y renvoient les coordonnées du coin supérieur gauche du widget, relativement à son parent :

 
Sélectionnez
$x = $widget->x();
$y = $widget->y();

XVI-I-3. Coordonnées relatives à la fenêtre racine

Les méthodes rootx et rooty renvoient les coordonnées du widget, relativement à la fenêtre racine :

 
Sélectionnez
$x = $widget->rootx();
$y = $widget->rooty();

Ces coordonnées désignent le coin supérieur gauche du widget.

XVI-I-4. Coordonnées du bureau virtuel

Certaines méthodes spéciales permettent d'obtenir des coordonnées relatives à un bureau virtuel, si vous en utilisez un. Les bureaux virtuels sont très courants sous X Window (notamment avec les gestionnaires de fenêtres fvwm et tvtwm), mais existent aussi sous Microsoft Windows.

Les méthodes vrootheight et vrootwidth renvoient, respectivement, la hauteur et la largeur du bureau virtuel :

 
Sélectionnez
$hauteur = $widget->vrootheight();
$largeur = $widget->vrootwidth();

Pour obtenir les coordonnées du coin supérieur gauche du widget, relativement au bureau virtuel, il suffit d'utiliser les méthodes vrootx et vrooty :

 
Sélectionnez
$x = $widget->vrootx();
$y = $widget->vrooty();

Ces quatre méthodes renvoient toutes une chaîne vide si elles ne détectent pas de bureau virtuel.

XVI-I-5. Coordonnées du pointeur de la souris relativement au bureau

Les méthodes pointerx, pointery et pointerxy permettent de déterminer l'emplacement sur lequel on a cliqué dans le widget :

 
Sélectionnez
$x = $widget->pointerx();
$y = $widget->pointery();
($x, $y) = $widget->pointerxy();

Toutes les coordonnées obtenues sont relatives au bureau (même s'il est virtuel).

XVI-J. Informations sur l'écran

Les méthodes suivantes renvoient des informations concernant l'écran (qui est un bureau normal ou virtuel) et les couleurs utilisées par le bureau.

XVI-J-1. Nom de l'écran

Chaque écran utilisé possède un nom ; pour le connaître, il suffit d'utiliser la méthode screen :

 
Sélectionnez
$nom = $widget->screen();

Le nom renvoyé sera au format "NomAffichage.IndexEcran" : il s'agit de ":0.0" sur ma machine Windows 95.

XVI-J-2. Hauteur et largeur de l'écran

La hauteur et la largeur de l'écran représentent, en fait, sa résolution. On a parfois besoin de ces informations pour connaître la dimension maximale d'une fenêtre qui dépend du système employé par l'utilisateur. Les méthodes screenheight et screenwidth renvoient ces deux valeurs exprimées en pixels :

 
Sélectionnez
$hauteur = $widget->screenheight();
$largeur = $widget->screenwidth();

Si la résolution de l'écran est de 768 par 1024 pixels, la première méthode renverra 768 et la deuxième 1024. Si l'on préfère obtenir ces valeurs en millimètres, il suffit d'utiliser screenmmheight et screenmmwidth :

 
Sélectionnez
$hauteur_mm = $widget->screenmmheight();
$largeur_mm = $widget->screenmmwidth();

La même résolution, 768 par 1024, font que ces méthodes renvoient, respectivement, 203 et 270 millimètres pour mon écran.

XVI-J-3. Nombre de cellules

La méthode screencells renvoie le nombre de cellules de la palette de couleurs par défaut :

 
Sélectionnez
$nombre = $widget->screencells();

La palette de couleurs par défaut de ma machine Windows 95 possède 64 cellules.

XVI-J-4. Profondeur de l'écran

La méthode screendepth renseigne sur le nombre de bits qu'utilise l'écran pour représenter un pixel :

 
Sélectionnez
$profondeur = $widget->screendepth();

Ma machine Windows 95 utilise 16 bits par pixel.

XVI-J-5. Type de couleur

Le type de couleur dépend de la classe de couleur employée. Les classes possibles sont "directcolor", "grayscale", "pseudocolor", "staticcolor", "staticgray", ou "truecolor". La méthode screenvisual renvoie celle de l'écran contenant le widget :

 
Sélectionnez
$type = $widget->screenvisual();

Pour connaître la classe de couleur du widget lui-même, on utilisera la méthode visual :

 
Sélectionnez
$type = $widget->visual();

La méthode visualsavailable permet de connaître la liste de toutes les classes disponibles pour la configuration courante :

 
Sélectionnez
@liste = $widget->visualsavailable();

Chaque élément de @liste décrit la classe et la profondeur de couleur de l'écran contenant le widget. Sur ma machine Windows 95, elle ne contient qu'un élément : "truecolor16".

XVI-J-6. Type de serveur

La méthode server renvoie le type du serveur d'affichage :

 
Sélectionnez
$serveur = $widget->server();

Le type de serveur de Windows 95 est "Windows 4.0 67109975 Win32".

XVI-J-7. Le widget est-il visible ?

Un widget est considéré comme visible si lui-même et tous ses ancêtres sont affichés. La méthode viewable interroge un widget sur sa visibilité courante :

 
Sélectionnez
$est_visible = $widget->viewable();

Cette méthode renvoie 1 si le widget est visible, 0 sinon.

XVI-K. Méthodes applicables aux atomes

À chaque widget est associé un atome constitué d'une chaîne contenant un nom (que l'on peut obtenir pour chaque widget à l'aide de la méthode name) et d'un identificateur sur 32 bits. Les méthodes que nous allons présenter ici sont utilisées de façon interne pour gérer des tâches telles que le mécanisme de sélection.

Si l'on passe le nom d'un widget à la méthode atom, celle-ci renvoie son identificateur 32 bits :

 
Sélectionnez
$id = $widget->atom($widget->name());

La démarche opposée consiste à passer l'identificateur du widget à la méthode atomname, afin d'obtenir son nom :

 
Sélectionnez
$nom = $widget->atomname($id);

XVI-L. Émettre un bip

Pour que l'ordinateur avertisse l'utilisateur par un signal sonore, on utilise la méthode bell :

 
Sélectionnez
$widget->bell();

XVI-M. Méthodes pour le presse-papiers

Les méthodes suivantes permettent de manipuler le presse-papiers interne de Tk, ainsi que celui du système de fenêtrage (X Window ou Win32).

La méthode clipboardAppend ajoute des données au presse-papiers :

 
Sélectionnez
$widget->clipboardAppend("données à ajouter");

Lorsque l'on appelle cette méthode, on peut indiquer un format à l'aide de l'option -format qui vaut, par défaut, "STRING". L'autre valeur possible est "ATOM". L'option -type peut également être utilisée, sa valeur est une chaîne telle que "STRING" ou "FILE_NAME".

Pour vider le presse-papiers (supprimer toutes les données qu'il contient), on utilisera la méthode clipboardClear :

 
Sélectionnez
$widget->clipboardClear();

Pour savoir ce qu'il y a dans le presse-papiers, étudiez la méthode selectionGet, traitée dans la section « Obtenir la sélection ».

XVI-N. Méthodes de sélection

Certains widgets permettent de sélectionner du texte ; c'est le cas, par exemple des widgets texte, des zones de saisie et des boîtes de liste. La sélection est manipulable par les méthodes suivantes.

XVI-N-1. Annuler la sélection

La méthode SelectionClear permet d'annuler la sélection courante (et une éventuelle sélection X) :

 
Sélectionnez
$widget->SelectionClear();

On peut utiliser une option -selection, valant "PRIMARY" par défaut. Si elle vaut "CLIPBOARD", le presse-papiers sera également vidé.

XVI-N-2. Obtenir le texte sélectionné

La méthode SelectionGet renvoie le texte sélectionné dans l'application :

 
Sélectionnez
$selection = $widget->SelectionGet();

L'option -selection est également reconnue par SelectionGet :

 
Sélectionnez
$presse_papier = $widget->SelectionGet(-selection => "CLIPBOARD");

Comme précédemment, -selection vaut "PRIMARY" ou "CLIPBOARD". La valeur par défaut est "PRIMARY" et, si l'on n'utilise pas cette option, la valeur renvoyée par SelectionGet sera donc le texte sélectionné dans l'application. Si cette option vaut "CLIPBOARD", la méthode renverra le contenu du presse-papiers.

XVI-N-3. Assignation d'une fonction de rappel

La méthode SelectionHandle permet d'assigner une fonction de rappel qui sera automatiquement invoquée lorsque la sélection de $fenetre sera modifiée :

 
Sélectionnez
$widget->SelectionHandle($fenetre => \&fct_rappel);

La fonction de rappel fct_rappel sera invoquée lorsqu'une sélection sera faite dans $fenetre. On peut utiliser les options -format, -type, et -selection en leur donnant les mêmes valeurs que dans les exemples précédents. Si le nom de la fonction de rappel passée à SelectionHandle est une chaîne vide, cela supprimera la fonction de rappel déjà assignée.

XVI-N-4. Connaître le propriétaire du texte sélectionné

La méthode SelectionOwner renvoie le widget propriétaire du texte sélectionné (le widget dans lequel la sélection a eu lieu).

 
Sélectionnez
$widget = $widget->SelectionOwner();

L'option -selection, et ses valeurs "PRIMARY" ou "CLIPBOARD", permet de préciser si elle appartiendra au propriétaire de la sélection ou au presse-papiers.

XVI-N-5. Attribuer un propriétaire à une sélection

La méthode SelectionOwn force un widget à devenir le propriétaire de la sélection :

 
Sélectionnez
$widget->selectionOwn();

Le type de sélection considéré sera éventuellement précisé via l'option -selection. L'option -command, associée à une fonction de rappel, permettra d'invoquer celle-ci lorsque cette sélection de widget sera forcée.

XVI-O. Suppression d'un widget

La méthode destroy détruit le widget sur lequel elle est appelée (l'utilisation de if Tk::Exists est recommandée) :

 
Sélectionnez
$widget->destroy() if Tk::Exists($widget);

Si le widget est parent d'autres widgets, ceux-ci seront également détruits.

XVI-P. Méthodes de gestion du focus clavier

La méthode focus, appelée sur un widget, permet de le forcer à posséder le focus clavier :

 
Sélectionnez
$widget->focus();

Cela peut s'avérer nécessaire si l'on dispose d'une zone de saisie dans laquelle l'utilisateur doit d'abord entrer des informations. L'appel de focus juste avant celui de la fonction MainLoop fera que le widget obtiendra le focus. Si l'on presse la touche de tabulation, le focus sera automatiquement passé au widget suivant (rappelez-vous que l'on sait qu'un widget a le focus grâce au rectangle qui l'entoure). Les méthodes suivantes permettent de manipuler le focus.

La méthode focusFollowsMouse permet au focus de suivre le pointeur de la souris :

 
Sélectionnez
$widget->focusFollowsMouse();

Cette méthode fonctionne mal, que ce soit sous Windows 95 ou sous Unix. Un correctif a récemment été mis au point pour Tk8 : assurez-vous de l'avoir appliqué si vous comptez utiliser cette méthode.

Pour savoir quel est le widget qui possède le focus, il suffit d'appeler la méthode focusCurrent :

 
Sélectionnez
$qui = $widget->focusCurrent();

La méthode focusForce force un widget à prendre le focus, même si l'application n'est pas active à ce moment-là :

 
Sélectionnez
$widget->focusForce();

Ce n'est pas une bonne pratique, aussi je vous conseille de ne pas le faire.

Pour connaître le widget ayant eu le focus en dernier, on utilisera la méthode focusLast :

 
Sélectionnez
$qui = $widget->focusLast();

Si aucun des widgets de la fenêtre n'a le focus, cette méthode renvoie celui de premier niveau.

Pour connaître l'ordre dans lequel le focus est passé aux widgets, on utilisera les méthodes focusNext et focusPrev :

 
Sélectionnez
$widget_suiv = $widget->focusNext();
$widget_prec = $widget->focusPrev();

XVI-Q. Méthodes de capture

Lorsqu'une fenêtre effectue une « capture », elle s'attribue toutes les entrées au clavier et à la souris et interdit donc aux autres fenêtres de l'application de recevoir des entrées. Il existe également une capture globale, qui bloque les entrées pour toutes les applications du système à l'exception de la fenêtre qui l'a effectuée. Ces méthodes sont généralement appelées sur un widget de premier niveau.

La méthode grab effectue une capture locale :

 
Sélectionnez
$widget->grab();

Avec une telle capture, on peut interagir avec d'autres applications du système, mais pas avec d'autres fenêtres de la même application que celle de $widget. Pour effectuer une capture globale, on utilisera la méthode grabGlobal :

 
Sélectionnez
$widget->grabGlobal();

Pour « relâcher », il suffit d'appeler la méthode grabRelease :

 
Sélectionnez
$widget->grabRelease();

La méthode grabCurrent renvoie le widget qui a effectué une capture :

 
Sélectionnez
$qui = $widget->grabCurrent();

La méthode grabStatus renvoie l'état de capture courant d'un widget :

 
Sélectionnez
$etat = $widget->grabStatus();

La chaîne renvoyée sera "none", "local", ou "global".

La méthode grabs renvoie la liste de toutes les fenêtres concernées par la capture courante :

 
Sélectionnez
@fenetres = $widget->grabs();

XVI-R. Communication entre les applications

La méthode send permet aux applications Perl/Tk (et Tcl/Tk) de communiquer. Ses paramètres sont l'application à contacter et la commande à exécuter par celle-ci :

 
Sélectionnez
$widget->send("application" => fct_rappel);

On peut également utiliser l'option -async afin de redonner immédiatement le contrôle à l'appelant au lieu d'attendre la fin de l'exécution de la fonction de rappel.

Par défaut, votre application renverra une erreur à une autre application essayant de communiquer avec elle. Si vous souhaitez autoriser ces communications, exécutez Tk::Receive($widget, "command") et faites très attention au contenu de la chaîne de commande : permettre à une application d'envoyer à la vôtre des commandes inconnues est dangereux.

Lorsque vous autorisez les communications entre applications, il est préférable de lancer votre script Perl avec le commutateur -T, qui force une vérification des instructions dangereuses.

XVI-S. Attente d'événements

En certains points d'une application, il peut s'avérer utile d'attendre qu'un événement survienne. Si, par exemple, on crée une fenêtre ColorEditor pour qu'elle assigne la couleur choisie à une variable, et que l'on souhaite que l'application attende que cette variable ait été affectée, on utilisera la méthode waitVariable :

 
Sélectionnez
$widget->waitVariable(\$var);

Le traitement continuera dès que la valeur de $var a été modifiée.

Pour attendre qu'un widget devienne visible, on utilisera waitVisibility :

 
Sélectionnez
$widget->waitVisibility();

La méthode waitWindow attendra que le widget concerné soit détruit :

 
Sélectionnez
$widget->waitWindow();

Lorsque l'on appelle ces méthodes, rien ne se passera tant que l'événement attendu n'a pas lieu.

Au lieu d'appeler waitWindow, on peut invoquer OnDestroy en lui passant une fonction de rappel en paramètre. Les méthodes du widget sont encore disponibles lorsque l'on utilise OnDestroy :

 
Sélectionnez
$widget->OnDestroy(sub {};

XVI-T. Événements concernant les fichiers

La méthode fileevent est une méthode spéciale : on l'utilise pour savoir si un fichier est accessible en lecture ou en écriture, et en être averti. Voici un exemple de code montrant son utilisation (il doit être exécuté sur un système Unix, car il utilise la commande tail(43)) :(44)

 
Sélectionnez
use Tk;
open (FIC, "tail -f -n 25 fichier_texte|") or
    die "Impossible d'ouvrir le fichier !!";
my $mw = MainWindow->new();
my $texte = $mw->Scrolled("Text",
                          -width => 80,
                          -height => 25)->pack(-expand => 1);
$mw->fileevent(FIC, 'readable', [\&inserer_texte]);

MainLoop();

sub inserer_texte
{
    my $ligne_courante;
    if ($ligne_courante = <FIC>) # lit la première des 25 dernières lignes
    {
        $texte->insert('end', $ligne_courante);
        $texte->yview('moveto', 100);
    }
    else {
        $mw->fileevent(FIC, 'readable', "");
    }
}

Une fois lancé, ce petit programme s'arrête pour attendre que le fichier soit lisible, puis insère l'information lue dans une zone de texte. On peut également utiliser 'writable' :

 
Sélectionnez
$mw->fileevent(FIC, 'writable', fct_rappel);

Si l'on ne précise pas le paramètre concernant la fonction de rappel, fileevent renverra celle qui est assignée. Si l'on passe une chaîne vide à la place de la fonction de rappel, celle qui est en place sera ôtée.

XVI-U. Traitement des options de la ligne de commande

Dans le monde Unix, il est courant de préciser des options sur la ligne de commande qui invoque une application : il n'est pas inhabituel de lancer un script par la commande monscript -geometry "80x40". Pour que Perl/Tk analyse et applique automatiquement ces options pour vous, il suffit d'appeler la méthode CmdLine immédiatement après la création de la fenêtre principale :

 
Sélectionnez
$mw->CmdLine();

Avec Tk4, si l'on souhaite que CmdLine arrête de traiter les paramètres de la ligne de commande et qu'elle en laisse certains que vous traiterez vous-même, il faut placer deux tirets (--) avant ceux que vous voulez qu'elle vous laisse :

 
Sélectionnez
monscript -geometry "80x40" -- -monoption

Avec Tk8.0, le traitement automatique des options cessera dès qu'une option inconnue est rencontrée.

Une autre façon de traiter les options de la ligne de commande consiste à utiliser les modules Getopts de Perl. Consultez l'ouvrage Programmation en Perl(45) pour savoir comment utiliser les fonctions disponibles de Getopts. Celles-ci ne gèrent pas les options pour vous, mais les placent dans une structure de données qu'il vous sera facile de traiter.

XVI-V. Temporisations

Par moment, un programme doit attendre un certain temps avant de poursuivre son exécution. Peut-être souhaitez-vous également qu'il exécute la même commande toutes les minutes ? La méthode after fera patienter votre programme pendant le nombre de millisecondes spécifié :

 
Sélectionnez
$widget->after(millisecondes);

Pour qu'une fonction de rappel soit invoquée après un certain délai, il suffit de la passer comme deuxième paramètre de after :

 
Sélectionnez
$id = $widget->after(millisecondes, fct_rappel);
# Exemple :
$id = $widget->after(1000, \&faire_qqchose);

Si vous souhaitez exécuter une fonction après une certaine période d'inactivité du programme, appelez la méthode afterIdle :

 
Sélectionnez
$id = $widget->afterIdle(fct_rappel);

La méthode afterCancel, utilisée avec l'identificateur renvoyé par l'appel à after ou afterIdle, annule cet appel :

 
Sélectionnez
$widget->afterCancel($id);
# On peut aussi utiliser :
$id->cancel();

La méthode repeat permet d'appeler la même fonction de rappel à intervalles réguliers :

 
Sélectionnez
$widget->repeat(millisecondes, fct_rappel) ;
# Exemple :
$widget->repeat(600, \&mettre_a_jour);

Si vous détruisez $widget, cela supprimera automatiquement tous les appels à after et repeat.


précédentsommairesuivant
NDT On rappelle que ce nombre permet de déterminer le nombre maximum de couleurs affichables simultanément. 16 bits par pixel, par exemple, permettent d'afficher simultanément 216 , soit 65536, couleurs différentes.
NDT « Caractère de fin de ligne absent de la ligne 2 du fichier C:\PERL\lib\site\Tk\Submethods.pm ligne 16 ».
NDT La commande tail -f -n 25 fichier_texte utilisée affiche les 25 dernières lignes du fichier fichier_texte puis attend que de nouvelles lignes lui soient ajoutées et les affiche alors.
Merci à mon ami Phivu Nguyen pour m'avoir permis d'emprunter ce code.

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.