• NOM
• SYNOPSIS
• DESCRIPTION
• LE SUPPORT DES MEGA WIDGETS
• PIEGES
• CE QUI MANQUE
• MOTS-CLÉS
• VOIR AUSSI
• TRADUCTION
• RELECTURE

NOM

Tk::mega - support perl/Tk pour écrire des widgets en Perl pur

SYNOPSIS

Définir le nom de la nouvelle classe de widget :

package Tk::MyNewWidget;

Pour les classes de widgets composites :

use base qw/ Tk::container /; # où container est une Frame ou une Toplevel

Pour les classes de widgets dérivées :

use base qw/ Tk::Derived Tk::DerivedWidget /;

Installer le nouveau widget dans l'espace de noms de Tk et créer les constructeurs d'instance :

Construct Tk::Widget 'MyNewWidget';

sub ClassInit { my ($self, $args) = @_; ... }

sub Populate { my ($self, $args) = @_; ... }

DESCRIPTION

Le but du support pour les mega widgets de perl/Tk est de faciliter l'écriture de mega widgets qui suivront le même protocole et auront la même interface que les widgets du coeur de Tk. Pour un exemple de code de mega-widget, vous devriez essayer le programme de démonstration widget, et aussi lire la section Exemples de Mega-Widgets Perl.

Il existe deux types de mega widgets :

Les widgets composites

Un widget composite est constitué d'un ou plusieurs widgets existant(s). Un widget composite se comporte du point de vue de l'utilisateur comme un widget unique. La boîte de sélection de fichier en est un exemple bien connu.

Les widgets dérivés

Un widget dérivé ajoute/modifie/supprime des propriétés et des méthodes à un seul widget (ce widget pouvant être lui-même un mega widget).

LE SUPPORT DES MEGA WIDGETS

Advertise

Donne au subwidget un nom symbolique.

Utilisation :

$cw->Advertise(nom=>$widget);

Donne au subwidget $widget du widget composite $cw le nom nom. On peut retrouver la référence d'un subwidget 'nommé' (advertised) avec la méthode Subwidget.

Commentaire : réalisateurs de mega widgets, merci de documenter les widgets 'nommés' destinés à une utilisation publique. S'il n'en existe pas, documentez ce fait, par exemple :

  =head1 ADVERTISED WIDGETS

  None.

Callback

Invoque un callback spécifié pour une option.

Utilisation :

$self->Callback(-option ?,args ...?);

Callback exécute le callback défini avec $mega->ConfigSpecs(-option, [CALLBACK, ...]) ; si les args existent ils sont passés au callback. Si -option n'est pas défini il ne se passe rien.

ClassInit

Initialisation de la classe du mega widget.

Utilisation :

sub ClassInit { my ($class, $mw) = @_; ... }

ClassInit est appelé une fois pour chaque MainWindow juste avant que la première instance de la classe du widget soit créée dans l'arbre des widgets de MainWindow.

ClassInit est souvent utilisé pour définir les liens (bindings) et/ou d'autres ressources partagées par toutes les instances, par exemple les images.

Exemples :

  $mw->bind($class,"<Tab>", sub { 
    my $w = shift; 
    $w->Insert("\t"); 
    $w->focus; 
    $w->break;
  }); 
  $mw->bind($class,"<Return>", ['Insert',"\n"]); 
  $mw->bind($class,"<Delete>",'Delete');

Remarquez que $class est le nom de classe (par exemple Tk::MyText) et $mw est la fenêtre principale.

N'oubliez pas d'appeler $class->SUPER::ClassInit($mw) dans ClassInit.

Component

Fonction pratique pour créer des subwidgets.

Utilisation :

  $cw->Component('Whatever', 'AdvertisedName', 
    -delegate => ['method1', 'method2', ...], 
    ... options du widget Whatever ...,
  );

Component effectue pour vous plusieurs choses dans un seul appel :

• Créer le widget

• Le 'nommer' avec un nom donné (écrasé par l'option 'Name')

• Déléguer un ensemble de méthodes à ce widget (optionnel)

Exemple :

  $cw->Component('Button', 'quitButton', -command => sub{ $mw->'destroy' });

ConfigSpecs

Définir les options et leur traitement :

Utilisation :

  $cw->ConfigSpecs( 
    -option => [ where, dbname, dbclass, default], 
    ..., 
    DEFAULT => [where],
  );

Définit les options d'un mega widget ainsi que les actions qui sont déclenchées par un configure/cget sur une option (voir Tk::ConfigSpecs et Tk::Derived pour les détails).

Construct

Rend le nouveau mega widget connu de Tk.

Utilisation :

Construct baseclass 'Name';

Construct déclare une nouvelle classe de widget, ainsi votre mega widget se comporte comme les widgets standard de Perl/Tk.

Exemples :

Construct Tk::Widget 'Whatever'; Construct Tk::Menu 'MyItem';

Le premier exemple permet l'utilisation de $widget->Whatever pour créer un nouveau widget Whatever.

Le deuxième exemple restreint l'usage de la méthode de constructeur MyItem à des widgets dérivées de Menu : $isamenu->MyItem.

CreateArgs

Traite les options avant la création de tout widget

sub CreateArgs { my ($package, $parent, $args) = @_; ...; return @newargs; }

$package est le package du mega widget (par exemple, Tk::MyText, $parent le parent du widget à créer et $args la référence au hash des options spécifiées lors de l'appel du constructeur du widget.

N'oubliez pas d'appeler $package->SUPER::CreateArgs($parent, $args) dans CreateArgs.

Delegates

Redirige une méthode du mega widget vers un subwidget du widget composite.

Utilisation :

  $cw->Delegates(
    'method1' => $subwidget1, 
    'method2' => 'advertised_name', 
    ..., 
    'Construct' => $subwidget2, 
    'DEFAULT'   => $subwidget3,
  );

La délégation 'Construct' a une signification spéciale. Après que 'Construct' soit délégué tous les constructeurs de widget sont redirigés. Par exemple après

$self->Delegates('Construct'=>$subframe);

un $self->Button effectue en réalité $subframe->Button et ainsi le button créé est un fils de $subframe et non de $self.

Commentaire : Delegates fonctionne uniquement avec des méthodes que $cw ne possède pas lui-même.

InitObject

Note: cette méthode ne devrait généralement pas être utilisée, parce qu'elle a été phagocytée par la méthode Populate ainsi que la spécification de Tk::Derived en tant que classe de base.

Définit la construction et l'interface de widgets dérivés.

Utilisation :

sub InitObject { my ($derived, $args) = @_; ... }

où $derived est la référence du widget de la classe de base déjà créé et $args la référence à un hash de paires -option => valeur.

InitObject est quasi identique à la méthode Populate. Populate réalise en plus quelques choses 'magiques' supplémentaires très utiles pour les mega widgets comportant plusieurs widgets.

N'oubliez pas d'appeler $derived->SUPER::InitObject($args) dans InitObject.

OnDestroy

Définit le callback invoqué lorsque le widget est détruit.

Utilisation :

$widget->OnDestroy(callback);

OnDestroy installe un callback qui sera appelé lorsqu'un widget va être détruit. Très utile pour des actions spéciales de nettoyage. Il diffère d'un destroy normal en ce que toute la structure de données du widget est encore intacte.

Commentaire : on peut utiliser cette méthode avec tous les widgets, et pas seulement avec les mega widgets. Elle est citée ici parce qu'elle est très utile.

Populate

Définit la construction et l'interface du widget composite.

Utilisation :

  sub Populate {
    my ($self, $args) = @_; 
    ...
  }

où $self est la référence du widget de la classe de base déjà créé et $args est la référence à un hash de paires -option => valeur.

La plupart des autres fonctions support sont normalement utilisées dans la sub Populate.

N'oubliez pas d'appeler $cw->SUPER::Populate($args) dans Populate.

privateData

Définit/renvoie un hash privé appartenant au widget pour stocker des données internes au composite.

Utilisation :

$hashref = $mega->privateData();

$another = $mega->privateData(unique_key|package);

Subwidget

Renvoie la référence d'un subwidget 'nommé'.

@subwidget = $cw->Subwidget ();

$subwidget = $cw->Subwidget(name);

@subwidget = $cw->Subwidget(name ?,...?);

Renvoie la (les) référence(s) d'un subwidget connu sous le(s) nom(s) name. Sans arguments, renvoie la liste de tous les subwidgets de $cw connus. Voir la méthode Advertise pour définir name pour un subwidget.

Commentaire : Utilisateurs de mega widget, utilisez Subwidget pour retrouver uniquement les subwidgets documentés.

PIEGES

• Resource DB class name
  Quelques-unes des options standard utilisent une classe de base de données de ressources qui n'est pas la même que le nom de la base de données de ressources. Par exemple,

    Switch :            Name :             Class :
    -padx               padX               Pad 
    -activerelief       activeRelief       Relief 
    -activebackground   activeBackground   Foreground 
    -status             undef              undef

  On devrait faire la même chose lorsqu'on définit une de ces options via ConfigSpecs.

• Délégation de méthode
  La redirection de méthodes vers un subwidget au moyen de Delegate ne peut fonctionner que si le widget de base lui-même possède une méthode de ce nom. Par suite on ne peut ``déléguer'' aucune des méthodes listées dans Tk::Widget. bind reste une méthode problématique courante. Dans ce cas il faut rediriger la méthode explicitement.

    sub bind {
      my $self = shift; 
      my $to = $self->privateData->{'my_bind_target'};
      $to->bind(@_);
    }

• privateData
  Graham Barr a écrit : ... C'est probablement encore plus privé que ne le pensent la plupart des gens. Tous les appels de privateData ne renvoient pas la même référence de HASH. La référence de HASH renvoyée dépend du package appelant, un HASH différent est renvoyé pour chaque package. Ceci permet à un widget de garder des données privées, mais s'il est sous-classé, la sous-classe aura un HASH différent et ne provoquera pas de clash de nom dupliqué.

  Mais privateData prend un argument optionnel si vous désirez forcer le renvoi d'un HASH particulier.

• Scrolled et Composite
  Le constructeur Scrolled(Kind,...) ne peut pas être utilisé avec Composite. Il faut utiliser $cw->Composite(ScrlKind => 'name', ...);

CE QUI MANQUE

Bien entendu perl/Tk ne définit pas de fonction support pour tous les besoins. Voici une courte liste des choses que vous devez gérer vousmême :

• pas de support pour définir des options traitées seulement au moment de la construction.

• pas de support pour supprimer une option connue du widget de base.

• il est difficile de définir undef pour une option de widget qui ne soit pas déjà undef.

• les Frame de perl/Tk comportent des choses ``magiques'' et supplémentaires [and overhead] non nécessaires à la définition de classe de widget composite.

• pas de support de méthodes pour les liens (bindings) partagés entre tous les widgets d'un widget composite (est-ce que cela a un sens ?)

MOTS-CLÉS

mega, composite, derived, widget

VOIR AUSSI

Tk::composite Tk::ConfigSpecs Tk::option Tk::callbacks Tk::bind

TRADUCTION

Jean-Pierre Vidal jeanpierre.vidal@free.fr

RELECTURE

Aucune relecture pour le moment