Les Associations (Binding)

Binding est quelquefois traduit par « liaison », mais le terme « association » paraît plus précis et liaison est mieux traduit par link. Une solution consisterait peut-être, à utiliser le terme de « ligature » moins galvaudé. Cette fonctionnalité, en apparence simple, offre de multiples ressources.

Formellement, cela s'écrit :

    $widget->bind(tag, descripteur => callback)

    $widget->bind(descripteur => callback)

où bind() est la méthode qui permet d'associer un événement X, défini par le champ descripteur. L'association se trouve faite soit avec :

la classe d'objets nommée dans le tag
les objets taggés par la méthode bindtags()
un widget et à tous ses descendants, si le tag n'est pas précisé

Si la fonction callback est la chaîne vide, alors l'association est détruite.

Par contre, lorsque l'on n'a spécifié que le descripteur, alors bind() renvoie le callback correspondant. Enfin, quand le descripteur ou le callback ne sont pas présents, c'est la liste des éléments associés qui est retournée, filtrée par le tag ou $widget (si le tag est aussi absent).

Maintenant nous allons examiner de plus près le descripteur. Il se compose de trois champs : le modificateur, le type, la touche (en anglais : detail).

On peut résumer la syntaxe par : descripteur=<modificateur-modificateur-...-modificateur-type-touche>. Les signes <>- font partie de la syntaxe.

La table ci-dessous résume les combinaisons possibles entre les champs :

    Modificateur                 Type                     Touche

    Control                      KeyPress                 Keysym
    Meta                         KeyRelease               Enter
    Alt                          ButtonPress ou Button    Right
    Shift                        ButtonRelease            Pickup
    Button 1 (ou B1)             Enter                    Delete
    Button 2 (ou B2)             Leave                    Backspace
    Double                       Motion                   Escape
    Any                                                   Help
    Triple                                                F1 .. F12
    Mod1, ..., Mod5 (ou M1, ..., M5)                          a-zA-Z0-9 etc.

Par exemple, on pourra écrire :

     $mainwindow->bind('Tk::Button','<Control-Alt-a>',\&some_callback) ;

Une association supplémentaire s'ajoutera à tous les boutons présents dans le widget principal $mainwindow. En effet, par défaut, les widgets Button possède déjà un certain nombre d'associations. Quand les touches Control, Alt et a seront pressées alors some_callback sera exécuté.

Pour illustrer cette partie, nous vous proposons le petit programme suivant qui affiche les coordonnées relatives et absolues du curseur. Pour ce faire, nous avons eu recours au widget Balloon qui permet de réaliser des infobulles.

    #!/usr/bin/perl -w
    ####-----------------------------------
    ### File    : bind.pl
    ### Author  : C.Minc
    ### Purpose :
    ### Version : 1.0 2003-12-10
    ####-----------------------------------

    use Tk;
    use Tk::Balloon;

    my $window = MainWindow->new;
    my $frame = $window -> Frame(-height => 50, -width => 150);
    $frame -> pack;
    my $ball = $window->Balloon(-statusbar => $window);
    $ball->attach($frame, -balloonposition => 'mouse', -msg => \$msg );
    $window->bind('<Motion>', [\&affich, Ev('x'), Ev('y'),  Ev('X'), Ev('Y')]);

    sub affich {
        my ($z, $x, $y, $X, $Y) = @_;
        $msg = $x . ":" .  $y . " at " . $X . ":" .  $Y;
    }
    MainLoop;

Lorsque la rétroaction est déclenchée, la construction Ev(code) est remplacée par la valeur du code du champ d'évènement X11. Ces codes sont nombreux, citons x et y pour les coordonnées relatives dans le widget, X et Y pour les coordonnées absolues dans l'écran, t pour avoir la date de l'évènement, k pour le code touche (keycode), K pour le nom de la touche (keysym) etc...

Citons pour être exhaustif, les « événements virtuels » au principe de construction similaire à celui que nous venons de décrire. Ils sont gérés par les quatre fonctions eventAdd, eventDelete, eventGenerate, eventInfo. eventAdd est utilisée pour associer le descripteur à l'événement virtuel.

Les << et >> font partie de la syntaxe et virtual_event représente une chaîne de caractères

    $widget->bind(tag,'<<virtual_event>>', callback);
    $widget->eventAdd('<<virtual_event>>', descripteur, ..., descripteur);

Par opposition, on appelle quelquefois les associations des événements physiques. Ces derniers, en cas de descripteur identique, sont prioritaires sur les événement virtuels. Ces derniers peuvent être associés (méthode bind), sans avoir été définis au préalable. Les événements virtuels offrent la possibilités de créer des associations dynamiques, c'est-à-dire qu'elles sont prises en compte immédiatement dans le déroulement du programme.

L'exemple, ci dessous, ouvre juste une fenêtre. Le fait de cliquer, de frapper contol-a, control-q, ou control-A provoque l'impression de messages. En particulier, on peut comparer le formalisme entre les deux types d'associations. De plus, la modification de l'évènement virtuel <<virtual_click2>> va provoquer l'alternance de réaction à control-a et control-A.

	#!/usr/local/bin/perl -w
	####-----------------------------------
	### File	: virtuel.pl
	### Author	: C.Minc
	### Purpose	:
	### Version	: 1.1 2004/5/3
	####-----------------------------------

	use Tk;
	use strict;
	my $mw = MainWindow->new;

	# association physique
	$mw->bind('<ButtonRelease-1>' => \&callback);

	# association virtuelle identique formellement à la précédente
	$mw->bind('<<virtual_click1>>'=>\&callback) ;

	# définition après coup de l'association virtuelle
	# avec changement de boutons pour pouvoir distinguer
	# les actions à l'exécution
	$mw->eventAdd('<<virtual_click1>>'=>'<ButtonRelease-2>','<ButtonRelease-3>') ;

	# illustration de l'effet dynamique des associations virtuelles

	$mw->eventAdd('<<virtual_click2>>'=>'<Control-q>','<Control-a>') ;
	$mw->bind('<<virtual_click2>>'=>[\&virtual,Ev('K')]) ;

	MainLoop;

	sub virtual {

 	 my ($objet,$touche)=@_ ;

  	if ( $touche eq 'A' ) {
    	$objet->eventDelete('<<virtual_click2>>') ;
    	$objet->eventAdd('<<virtual_click2>>'=>'<Control-a>','<Control-q>') ;
  	} elsif ($touche eq 'a') {
    	$objet->eventDelete('<<virtual_click2>>') ;
    	$objet->eventAdd('<<virtual_click2>>'=>'<Control-A>','<Control-q>') ;
  	}

  	print "virtual event  touche:$touche \n";
	}

	sub callback {
 	 print "callback args  = @_\n";
	}

Widgets Menu, Menubutton

Un problème récurrent est la création des menus. En général, on y trouve des boutons radios, des boutons à cliquer, des menus déroulants, en cascade ou des popups, des barres de menus.

Les widgets Menu et Menubutton sont complémentaires. Menubutton permet de créer le bouton auquel sera associé un menu et les sous-menus. Donc, pour créer une barre de menus, il suffit de générer un cadre qui contiendra les boutons de menu nécessaires.

Les trois exemples ci-dessous vont nous servir à analyser différentes approches. Afin de montrer le degré de souplesse existant, nous avons placé toutes les données dans le package suivant :

    ####-----------------------------------
    ### File    : taverne.pm
    ### Author  : C.Minc
    ### Purpose : Données communes aux prg tavernexx.pl
    ### Version : 1.0 2003-12-10
    ####-----------------------------------

    package taverne;
    require Exporter;
    use strict;

    # déclaration des variables externes
    use vars qw(
            @ISA
            @EXPORT
            @EXPORT_OK
            @menu
            %sous_menu
            %var
            &send_command
    );
    @ISA = qw(Exporter);
    @EXPORT_OK = qw(
            @menu 
            %sous_menu
            %var
            &send_command
            @Soupes 
            @Pates 
            @Plat_Garnis 
            @Hamburgers
    );

    # données du menu principal
    @menu = ("Soupes", "Pates", "Plats Garnis", "Hamburgers");

    # données des sous-menus
    my @Soupes = ("soupe de légumes", "gratinée à l'oignon"); 
    my @Pates = ("Pâtes au saumon frais, crème à l'Aneth", "Bolognèse", "Carbonara");
    my @Plat_Garnis = (
            "Poulet Rôti", "Escalope milanaise Spaghetti",
            "Magret de Canard Rôti dans sa peau au Miel",
            "Pavé de Saumon grillé"
    );
    my @Hamburgers = ("Hamburger pommes frites", "Cheeseburger", "Bacon cheeseburger");

    # Définition des références aux sous-menus
    %sous_menu = (
            Soupes         => \@Soupes,
            Pates          => \@Pates,
            "Plats Garnis" => \@Plat_Garnis,
            Hamburgers     => \@Hamburgers
    );

    sub send_command {

        use Mail::Sendmail qw(%mailcfg sendmail);

        $mailcfg{smtp} = [qw(smtp.wanadoo.fr localhost)];
        my ($customer, $taverne) = @_;
        my $monchoix = "\nVeuillez trouver ci-dessous mon choix :\n";

        foreach (keys %var) { 
            $monchoix .= "\t\t" . $_ . "\n"  if( defined($var{$_}) );
        }

        my %mail = (  To      =>  $taverne,
                      From    =>  $customer,
                      Message =>  $monchoix,
                      Subject =>  'commande'
        );

        sendmail(%mail) or die $Mail::Sendmail::error;
        print "OK. Log says:\n", $Mail::Sendmail::log;
        print "$monchoix";

    }

    1;

Nous avons donc quatre tableaux et un hash. Le tableau @menu contient les noms des sous-menus, chaque sous-menu contient des données qui pourront être utilisées de manières diverses. Le hash %sous_menu contient les références des tableaux des sous-menus (Soupes, Pates, Plat_Garnis, Hamburgers).

Le premier exemple ci-dessous part de la création d'un « bouton menu » (Menubutton). Après, l'opération se fait en quatre temps : création des références aux sous-menus (méthode menu->Menu()), mise en cascade des sous-menus (méthode add()), puis des données du bouton menu (méthode cascade()) et enfin, liaison entre les données et les références des sous-menus (méthode entryconfigure()) comme une sorte de « feedback ».

    #!/usr/bin/perl -w
    ####-----------------------------------
    ### File    : taverne1b.pl
    ### Author  : C.Minc
    ### Purpose :
    ### Version : 1.0 2003-12-10
    ####-----------------------------------
    use strict;
    use Tk;
    use taverne qw(@menu %sous_menu);

    my %sous_menuref;

    my $mw = MainWindow->new(-title => 'taverne1');
    my $fr = $mw->Frame-> pack;

    # création du bouton menu
    my $b_menu = $mw->Menubutton(-text => '   Menu de la Taverne   ',
                                 -relief => 'raised',
                                 -underline => 3,
                                )->pack(-fill => 'x');

    foreach my $m (@menu) {
        # création des sous-menus en cascade
        $sous_menuref{$m} = $b_menu->menu->Menu;
        # entrées des données des sous-menus
        map( $sous_menuref{$m}->add('command', -label => $_), @{$sous_menu{$m}} );
        # entrées des données du menu
        $b_menu->cascade(-label => $m);
        # associations entre le nom ($m) du sous-menu et sa référence $sous_menuref
        $b_menu->entryconfigure($m, -menu => $sous_menuref{$m});
    }

    MainLoop;

[Figure taverne1] [Figure taverne2]

La figure « taverne1 » illustre la structure en cascade obtenue à partir d'un bouton menu. Les sous-menus sont par défaut, détachables (option tearoff => 1, 0 pour le contraire).

On passe de la figure « taverne1 » à la figure « taverne2 » en changeant juste la ligne :

    map( $sous_menuref{$m}->add('command', -label => $_), @{$sous_menu{$m}} );

par celle-ci

    map( $sous_menuref{$m}->checkbutton(-label => $_), @{$sous_menu{$m}} );

Ce deuxième exemple ressemble beaucoup au premier, mais la différence principale réside dans la disposition en ligne de la racine des menus.

    #!/usr/bin/perl -w
    ####-----------------------------------
    ### File    : taverne3b.pl
    ### Author  : C.Minc
    ### Purpose :
    ### Version : 1.0 2003-12-10
    ####-----------------------------------
    use strict;
    use Tk;
    use English;
    use taverne qw(@menu %sous_menu);

    my %b_menu;
    my %var;
    my $v;
    my %sous_menux;

    my $mw = MainWindow->new(-title => 'taverne3');
    my $fr = $mw->Frame-> pack;
    my $b = $mw->Button(
                -text => 'Quit',
                -command => sub{
                    foreach (keys (%var)) {
                        print "<$_>\n" if defined $var{$_};
                    } 
                    exit;
                }
    ) -> pack(-side => 'top', -expand => '0', -fill => 'x');

    map($b_menu{$_} = $mw->Menubutton(
                        -text => $_,
                        -relief => 'raised',
                        -underline => 0,
        ) -> pack(-anchor => 'n', -side => 'left', -fill => 'x', -expand => '1'), 
        @menu
    );

    foreach my $m (@menu) {
        $sous_menux{$m} = $b_menu{$m}->menu->Menu;
        map( $b_menu{$m}->checkbutton(-label => $_, -variable => \$var{$_}), 
             @{$sous_menu{$m}}
        );
    }

    MainLoop;

Et nous obtenons la figure « taverne3 ». Le procédé est le même que pour la figure « taverne1 » si ce n'est que nous avons en quelque sorte multiplié le nombre des Menubutton.

[Figure taverne3]

Le programme suivant, sans doute, encore très simpliste, affiche une barre de menu en utilisant cette fois, le widget Menu avec l'option menubar. Le bouton "Envoyer" permet à la fin, d'envoyer la sélection par email grâce au callback sendcommand. (Cela autoriserait, par exemple de passer une commande via un terminal WAP ou UMTS dans le futur, quand Perl sera disponible sur ces dispositifs.) Cet exemple montre particulièrement la puissance de Perl et de Perl/Tk pour réaliser une programmation ultra compacte.

    #!/usr/bin/perl -w
    ####-----------------------------------
    ### File    : taverne4b.pl
    ### Author  : C.Minc
    ### Purpose :
    ### Version : 1.0 2003-12-10
    ####-----------------------------------
    use strict;
    use Tk;
    use taverne qw(@menu %sous_menu %var &send_command);

    my %sous_menuref;

    my $mw = MainWindow->new(-title => 'taverne4');
    $mw->geometry("300x6");
    my $top = $mw->toplevel;

    my $menubar = $top->Menu(-type => 'menubar');
    $top->configure(-menu => $menubar);

    foreach my $m (@menu) {

        # création des sous-menus en cascade
        $sous_menuref{$m} = $menubar->cascade(-label => $m);

        # entrées des données des sous-menus
        map( $sous_menuref{$m}->checkbutton(-label => $_, -variable => \$var{$_}), 
             @{$sous_menu{$m}}
        );
    }

    # un petit repentir : On rajoute le bouton 'Envoyer' dans le menu
    # avec un callback qui mail la commande From $customer To $taverne 

    # adresses humoristiques
    my $customer = 'table5.fauteuil2.taverne.republic@liberte.fr';
    my $taverne = 'lecuisinier.taverne.republic@liberte.fr';

    my $smref = $menubar->command(
                    -label => 'Envoyer',
                    -command => [\&send_command, $customer, $taverne]
    );

    MainLoop;

L'exécution du programme donne la figure « taverne4 ». La comparaison avec la figure « taverne2 » montre un résultat similaire et ce, comme nous l'avons déjà souligné, avec une programmation beaucoup plus limpide.

[Figure taverne4]

Nous espérons, par ces exemples, avoir pu vous montrer toute la souplesse des solutions, puisque toutes ces présentations ont été établies à partir des mêmes données.