Introduction à Perl/Tk

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▲

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

XVI-A-2. Nom d'un widget▲

$nom = $widget->name();

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

bouton
bouton1

XVI-A-3. Parent d'un widget▲

$parent = $widget->parent();

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

$chemin = $widget->toplevel();

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

$gestionnaire = $widget->manager();

XVI-A-6. Classe d'un widget▲

XVI-A-7. Identificateur d'un widget▲

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

XVI-A-8. Chemin d'un widget▲

$chemin = $widget->pathname($id);

$chemin = $mw->PathName();

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 ?▲

$est_pleine = $widget->colormapfull();

XVI-B-2. Nombre de cellules▲

$nbre = $widget->cells();

XVI-B-3. Profondeur de couleur▲

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

XVI-B-4. Conversion en valeur RGB▲

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

XVI-B-5. Configuration des couleurs▲

$widget->setPalette(couleur);

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

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

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 :

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

$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

$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".

$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).

$widget->optionAdd(motif => valeur);

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

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

$widget->optionClear();

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

$widget->optionGet(nom, classe);

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 :

$mw->appname("nouveau_nom");

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

$name = $mw->appname();

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

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 !

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

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.

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 :

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

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

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▲

$geom = $widget->geometry();

XVI-H-2. Hauteur demandée▲

$hauteur = $widget->reqheight();

XVI-H-3. Largeur demandée▲

$largeur = $widget->reqwidth();

XVI-H-4. Largeur réelle▲

$largeur_courante = $widget->width();

XVI-H-5. Hauteur réelle▲

$hauteur_courante = $widget->height();

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

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

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

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

$x = $widget->x();
$y = $widget->y();

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

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

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

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

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

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

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

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▲

$nom = $widget->screen();

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

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

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

XVI-J-3. Nombre de cellules▲

$nombre = $widget->screencells();

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

$profondeur = $widget->screendepth();

XVI-J-5. Type de couleur▲

$type = $widget->screenvisual();

$type = $widget->visual();

@liste = $widget->visualsavailable();

XVI-J-6. Type de serveur▲

$serveur = $widget->server();

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

$est_visible = $widget->viewable();

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

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

$nom = $widget->atomname($id);

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

$widget->bell();

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 :

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

$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 ».

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▲

$widget->SelectionClear();

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

$selection = $widget->SelectionGet();

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

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

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

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

$widget = $widget->SelectionOwner();

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

$widget->selectionOwn();

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

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

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

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

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

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

$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à :

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

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

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

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 :

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

$widget->grabGlobal();

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

$widget->grabRelease();

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

$qui = $widget->grabCurrent();

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

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

@fenetres = $widget->grabs();

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 :

$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.

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 :

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

$widget->waitVisibility();

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

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

$widget->OnDestroy(sub { … };

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)

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

$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.

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 :

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

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.

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

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

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

$id = $widget->afterIdle(fct_rappel);

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

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

$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.