NOTE : Ce manuel est en cours de rédaction. Il évolue quotidiennement ou presque. Reste à faire : - les widgets - les comportements - les inclassables - l'utilisation de tkZinc - reprendre la partie 1 et mettre des exemples Ce manuel utilisateur a pour objectif de faciliter l'utilisation de MTools. La première patie décrit en détail les fonctionnalités générales c'est à dire celles communes à tous les objets MTools. La deuxième partie décrit l'utilisation spécifique de chaque objet. PARTIE 1 : Les fonctionnalités communes --------------------------------------- 1.1 MTools.pm ------------- Cette partie de la documentation est principalement extraite de MTools.pm MTools exporte des fonctions destinées principalement à : - activer des fonctions propres à la librairie mtools - assurer la compatibilité entre la manipulation des objets mtools et des objets zinc Ainsi, d'une manière générale, toutes fonctions exportées s'appliquent aussi bien à des objets zinc qu'à des objets mtools. L'unique restriction est dans la méthode d'appel : - obligatoirement : fct ($obj, @parametres) pour un objet zinc - indiferemment $obj -> fct (@parametres). L'avantage de la première méthode est qu'elle s'applique aussi bien à un objet zinc qu'à un objet MTools. L'inconvénient est que l'on perd la possibilité de profiter de l'héritage et de la redéfinition éventuelle de la fonction. La fonction particuliere "new" : La fonction "new" permet de générer une nouvelle frame encapsulant un canvas zinc. Une frame MTools est unique pour une application. Elle initialise par ailleurs les données génériques pour le fonctionnement de MTools. Les callbacks dans MTools : \&fct : exécution de fct () [\&fct, @params] : exécution de fct (@params) ['fct_name', $obj, @params] : exécution de $obj -> fct_name (@params) [$obj, 'fct_name', @params] : exécution de $obj -> fct_name (@params) [$obj, \&fct_name, @params] : exécution de fct_name ($obj, @params) Fonctions : - propertyExists : teste si une propriété MTools a été enregistrée (par recordProperty) pour l'objet en question. S'il s'agit d'un objet zinc la valeur retournée est forcément 0. - mconfigure : permet de configurer indifférement des propriétes zinc ou MTools d'un objet. Les paramètres sont passés sous forme d'une table de hash. Par habitude, les propriétes zinc ou definies pour assurer une compatibilité avec zinc (comme '-visible') ont été précédées d'un '-'. - mget : $obj -> mget ('propriete') permet de récupérer la valeur d'une propriété - plisten : $obj -> plisten ('property_name', callback) plisten permet d'écouter les modifications des propriétés mtools d'un objet => associe l'appel d'une fonction à la modification d'un objet MTools - unplisten : $obj -> unplisten ('property_name', callback) supprime l'écoute - plink : plink ([$obj1, 'property_1'], [$obj2, 'property_2'], ...); Synchronise n propriétés. Si property_1 est modifiée, property_2 prendra la valeur de property_1 et réciproquement. À l'initialisation, toutes les propriétés prennent la valeur de property_1. - executer : executer (callback); permet d'exécuter une callback du type predefini ci-dessus dans la section "Les callbacks dans MTools" - binding : $obj -> binding ('evenement', callback) permet d'écouter un évènement MTOOLS ou Tk survenant sur un objet. binding peut aussi être redéfini pour écouter de nouvelles sources d'évènements (par exemple MIvy ou WacomAdapter) - unbinding : $obj -> unbinding ('evenement', callback) arrête l'écoute d'un évènement - minstanciate : minstanciate ('definition', $parent) permet de retourner un objet MTools à partir de la spec 'definition' . si 'definition' est un path svg, minstanciate instancie le svg et retourne un objet MTools encapsulant le contenu . si 'definition' est un objet zinc, minstanciate retourne un objet MTools encapsulant l'objet zinc . si 'definition' est déjà un objet MTools, minstanciate retourne l'objet lui-meme. minstanciate change également le groupe parent qui deviendra obligatoirement $parent - minstance : minstance ($objet, $parent) est le cousin de minstanciate mais lui retourne obligatoirement un objet zinc - mrun : lance l'exécution de la main loop. - mfind : $objet -> mfind ('tag') permet de chercher un fils de l'objet ayant le tag correspondant - mplaying : permet de lire un fichier son Les fonctions suivantes encapsulent l'exécution des fonctions zinc associées. Voir la documentation zinc : http://www.tkzinc.org/Documentation/refman-3.3.4/index.html - raise - scale - translate - rotate - coords - bbox - width - height - type - tset - treset - tget - clone - chggroup 1.2 MObjet.pm ------------- Cette partie de la documentation est principalement extraite de MObjet.pm Le composant MObjet est l'objet racine des composants MTools. Il definit les fonctions applicables uniquement aux objets MTools. IMPORTANT : Une autre partie des fonctions applicables aux objets MTools est définie dans la classe MTools. La différence entre ces deux classes de fonctions est que les fonctions définies dans MTools sont également applicables à des objets zinc tandis que les fonctions définies ici ne peuvent être appliquées qu'à des objets héritant de MTools::MObjet. Concepts : - Objet MTools : objet héritant de MObjet - Les PROPERTY : les propriétés sont des attributs particuliers et modifiables par un appel à "mconfigure". Elles peuvent être écoutées et synchronisées avec d'autres propriétés MTools ou meme zinc ! (cf MTools::plink et MTools::plisten). En conséquence elles sont là pour engendrer un comportement consécutif à leur modification et doivent être distinguées des attibuts qui peuvent se contenter d'être des clef de hash de l'objet. - Les EVENT : les évènements peuvent être émis par n'importe quel objet MTools et captés par un binding. Les fonctions publiques : - recordEvent : permet de permettre à un objet MObjet d'émettre un évènement. - recordProperty : permet de déclarer et initialiser une propriété. NOTA : il pourrait manquer une déclaration collective des propriétés. Initialement, celle-ci n'a pas été effectuée pour essayer de limiter l'usage des propriétés et ne pas les utiliser comme des attributs. - notify : permet à un objet MTools de notifier un évènement préalablement enregistré par recordEvent - propagate : permet à un objet de propager un évènement émis par un autre objet (correspond à un recordEvent puis un binding sur un évènement d'un objet effectuant le notify du meme évènement depuis l'objet declarant la propagation) PARTIE 2 : Les objets de MTools ------------------------------- 2.1 Les éléments graphiques --------------------------- Les objets graphiques élémentaires sont de type MObjet. Ils se trouvent dans MTools::GUI. _______ MCircle : l'objet cercle. La création nécessite les arguments suivants : - parent : père de l'objet. - x, y : coordonnées du centre du cercle - r : rayon du cercle - %options : table de hash passée en paramètre de la création de l'objet zinc arc Exemple d'utilisation : use MTools; use MTools::GUI::MCircle; new MTools (800, 600, "Exemple de cercle"); my $cercle = new MTools::GUI::MCircle (1, 400, 300, 220); my $disque = new MTools::GUI::MCircle (1, 400, 300, 200, -filled => 1, -fillcolor => "red"); mrun; ________ MRect.pm : l'objet rectangle. La création nécessite les arguments suivants : - parent : père de l'objet. - x, y : coordonnées de l'angle en haut à gauche du rectangle - w, h : largeur et hauteur du rectangle - %options : table de hash passée en paramètre de la création de l'objet zinc rectangle Exemple d'utilisation : use MTools; use MTools::GUI::MRect; new MTools (800, 600, "Exemple de rectangle"); my $contour = new MTools::GUI::MRect (1, 400, 300, 200, 10); my $surface = new MTools::GUI::MRect (1, 400, 400, 200, 20, -filled => 1, -fillcolor => "red"); mrun; _________ MGroup.pm : cet objet permet de regrouper d'autres objets, qui peuvent aussi être des groupes. Le groupe est vu et manipulé comme un objet unique. La création nécessite les arguments suivants : - parent : père de l'objet. - %options : table de hash passée en paramètre de la création de l'objet zinc groupe Exemple d'utilisation : use Math::Trig; use MTools; use MTools::GUI::MRect; use MTools::GUI::MGroup; new MTools (800, 600, "Exemple de groupe"); my $group = new MTools::GUI::MGroup (1); my $contour = new MTools::GUI::MRect ($group, 400, 300, 200, 10); my $surface = new MTools::GUI::MRect ($group, 400, 400, 200, 20, -filled => 1, -fillcolor => "red"); clone($group); $group->rotate(pi/4, 400, 300); mrun; ________ MClip.pm : l'objet permettant de faire du clipping. Le clipping est une technique qui consiste à réaliser une fenêtre de visualisation. En pratique, le clip est un objet qui définit une surface. Les portions du groupe clippé qui se trouvent à l'intérieur de cette surface sont visibles, tout ce qui est en dehors n'est pas affiché. La création nécessite les arguments suivants : - clipped : groupe zinc à clipper - path : description de l'objet clippant - soit une descrition sous forme [_type, _coords] créant un objet zinc de type _type et de coordonnées _coords - soit un objet existant qui prendra pour père le groupe $clipped. Note : un clip peut être rendu visible (ce qui signifie qu'il joue son rôle de masquage) ou non visible (pas de masquage) avec la propriété "-visible". Exemple d'utilisation : use MTools; use MTools::GUI::MGroup; use MTools::GUI::MCircle; use MTools::GUI::MRect; use MTools::GUI::MClip; new MTools (800, 600, "Exemple de clip"); my $fenetre = new MTools::GUI::MGroup (1); my $disque = new MTools::GUI::MCircle ($fenetre, 400, 300, 100, -filled => 1); my $trou = new MTools::GUI::MRect ($fenetre, 250, 300, 100, 60); new MTools::GUI::MClip ($fenetre, $trou); mrun; _________ MCurve.pm : l'objet curve permet de réaliser une forme quelconque, composée de segments et de courbes de Bézier. La création nécessite les arguments suivants : - parent : père de l'objet. - coords : coordonnées de la curve (cf. format zinc) - %options : table de hash passée en paramètre de la création de l'objet zinc curve Exemple d'utilisation : use MTools; use MTools::GUI::MCurve; new MTools (800, 600, "Exemple de curve bémol"); my $b = new MTools::GUI::MCurve(1, [[100, 100], [100, 300], # barre verticale [200, 300, 'c'], # bas de l'arrondi [200, 200, 'c'], # haut de l'arrondi [100, 250]],-linewidth=>3);#point d'accroche mrun; _________ MImage.pm : l'objet image permet de charger une image à partir d'un fichier. Actuellement, MImage gère les images au format png. Les autres formats marchent probablement, à vérifier*** (à moins que ce soit pour les svg). La création nécessite les arguments suivants : - parent : père de l'objet. - image : nom de l'image - %options : table de hash passée en paramètre de la création de l'objet zinc icon Exemple d'utilisation : use MTools; use MTools::GUI::MImage; new MTools (800, 600, "Exemple d'image"); my $image = new MTools::GUI::MImage (1, "plan.png"); mrun; ________ MText.pm : l'objet texte permet d'afficher des caractères. La création nécessite les arguments suivants : - parent : père de l'objet. - text : le texte à afficher - x, y : coordonnées de l'emplacement de l'objet - %options : table de hash passée en paramètre de la création de l'objet zinc text Exemple d'utilisation : use MTools; use MTools::GUI::MText; new MTools (800, 600, "Exemple de texte"); my $message=new MTools::GUI::MText(1,"Texte d'exemple",100,100,-color=>"gray"); mrun; ___________ MTexture.pm : Permet d'appliquer une texture à un objet. Une texture est une image qui sert de motif au remplissage d'une figure. Comme pour une tapisserie, la texture est répétée autant de fois que nécessaire pour couvrir toute la surface. Le coin en haut à gauche de la texture est aligné avec le coin en haut à gauche de la bbox de la figure à remplir. La création nécessite les arguments suivants : - parent : père de l'objet. - target : groupe zinc ou objet MTools définissant le contour de la figure. - image_name : nom de l'image texture (fichier png) Tester avec les autres formats*** Exemple d'utilisation : use MTools; use MTools::GUI::MCurve; use MTools::GUI::MTexture; new MTools (800, 600, "Exemple de texture"); my $surface = new MTools::GUI::MCurve (1, [[150, 50], [400, 100, 'c'], [750, 50], [750, 550], [400, 500, 'c'], [50, 550]]); my $texture = new MTools::GUI::MTexture(1, $surface, "plan.png"); mrun; 2.2 Le SVG ---------- SVG signifie Scalable Vector Graphics. Il s'agit d'un format standard puisqu'il correspond à une spécification du W3C. Cette standardisation permet aux fichiers svg d'être utilisés par plusieurs applications (par exemple Adobe Illustrator, inkscape sous Linux). Les fichiers svg permettent de décrire une image de manière vectorielle (par opposition à la description matricielle d'une photo). Les fichiers svg vont être utilisés pour décrire l'apparence des éléments graphiques d'une interface. Le graphiste pourra alors faire évoluer l'aspect d'une interface en modifiant les fichiers svg avec son éditeur favori. Cela revient à externaliser l'aspect visuel du code qui gère les comportements. NOTE : pour que la collaboration entre développeur et designer graphique se passe bien, il est important de définir clairement l'interface d'échange. Un outil de conversion (SVG2zinc) lit un fichier svg et le convertit en code perl. Ce code perl crée les objets graphiques zinc équivalents à ceux décrits dans le svg. Les noms des objets sont conservés, on peut donc par exemple faire une recherche d'un élément portant un nom particulier. Sur cet élément, on peut faire toutes les manipulations que l'on peut faire sur un objet zinc, puisque c'est un objet zinc ! Le code perl est généré dans le répertoire AUTOGEN. Le code perl est automatiquement regénéré si le fichier svg a été modifié. Le code perl construit des objets zinc, on a donc un arbre d'objets zinc qui reflète la description du svg. Il existe plusieurs manières de créer des objets graphiques à partir de la description contenue dans un fichier svg : - SVGLoader::load(svg, groupe parent) Cette fonction actualise AUTOGEN si nécessaire. Elle crée et retourne un objet perl dont le nom du type est construit à partir du nom svg. Cet objet hérite de MGroup. Le groupe parent est celui donné en paramètre. - MTools::minstanciate(svg, groupe parent) Cette fonction fait appel à SVGLoader::load et retourne un objet MTools. L'avantage de cette fonction c'est qu'elle est facile d'accès à tous les objets qui héritent de MTools. NOTE : cette fonction sait faire plus que charger du svg, voir le chapitre traitant de MTools.pm pour plus de détails. - MTools::minstance : minstance (svg, groupe parent) Idem que minstanciate mais retourne obligatoirement un objet zinc. - MSwitch : la description des états d'un switch peut utiliser directement un nom svg. Voir la description de MSwitch. Le nom svg doit indiquer le nom du fichier svg et l'élément que l'on cherche. Exemple d'utilisation : use MTools; new MTools (800, 600, "Exemple de svg"); my $svg = minstance("basique.svg#layer1", 1); my $mauve = minstance("basique.svg#mauve", 1); rotate($mauve, 45); my $ellipse = mfind($svg, "ellipse"); translate(clone($ellipse), 200, 0); mrun; *** comment faire marcher avec un nom de svg seul (sans spécifier #...) ? 2.3 Les widgets --------------- Les widgets sont des composants graphiques standard dans les IHM WIMP. Le fait de les utiliser permet de gagner du temps au lieu de refaire toujours les mêmes objets basiques. __________ MBouton.pm _______________ MRadioBouton.pm ______________ MRadioGroup.pm _____________ MSplitPane.pm ________________ MToggleBouton.pm 2.4 Les transformations ----------------------- Toutes les transformations peuvent être réalisées par appel de fonction comme on le fait avec zinc. Par exemple, sur un objet on peut enchaîner des appels à translate, rotate, scale. Les transformations successives se combinent. Une autre méthode consiste à appliquer un objet transformation à un objet graphique. L'intérêt est de pouvoir modifier une transformation au lieu de cumuler des transformations (ce qui nécessite de travailler par différence). ____________ MRotation.pm : L'objet rotation permet d'appliquer une rotation à un objet. La création nécessite les arguments suivants : - target : objet qui subit la transformation - angle : l'angle de rotation en degrés (sens horaire !) - x, y : coordonnées du centre de la rotation Les trois derniers arguments sont facultatifs, la valeur par défaut est 0. Les valeurs modifiables par mconfigure sont : - target - angle - x, y - -visible : mettre la rotation non visible consiste à ne pas effectuer de rotation (angle 0). Rendre la rotation visible rétablit la rotation. Exemple d'utilisation : use Tk; use Math::Trig; use MTools; use MTools::GUI::MRect; use MTools::Transform::MRotation; new MTools (800, 600, "Exemple de rotation"); my $background = new MTools::GUI::MRect (1, 0, 0, 800, 600, -filled => 1, -fillcolor => "lightblue"); my $barre = new MTools::GUI::MRect(1, 400, 300, 200, 20, -fillcolor => "pink"); $barre->rotate(-(pi/2), 400, 300); my $rotation = new MTools::Transform::MRotation($barre, 0, 400, 300); $background->binding('', [\&moved, Ev('x'), Ev('y')]); mrun; sub moved { my ($x, $y) = @_; $rotation->mconfigure('angle' => $x); } 2.5 Les animations ------------------ Une animation est une évolution progressive d'un paramètre d'un objet graphique. Les animations proposées sont : - changement de transparence - changement de position (translation ou parcours complexe) - changement de taille ___________ MOpacity.pm : MOpacity permet de réaliser une animation sur la transparence d'un ou plusieurs groupes ou autres objets ayant une propriété nommée "-alpha". La fonction de création ne nécessite aucun argument. Elle permet de configurer toutes les propriétés comme mconfigure. Les valeurs modifiables par mconfigure sont : - -visible : permet d'activer ou stopper l'animation - from_opacity : valeur initiale de l'opacité au départ de l'animation - to_opacity : valeur de l'opacité à la fin de l'animation - duration : durée de l'animation (défaut : 1s) - loop : indique le caractère répétitif de l'animation (défaut : faux) - targets : objet ou tableau d'objets cible de cette animation. Ces objets doivent disposer d'une propriété "-alpha" (c'est le cas des MGroup) Les valeurs d'opacité vont de 0 (transparent) à 100 (opaque). Les évènements émis sont : - ANIMATION_END : Notifie la fin de l'annimation - OPACITY_CHANGED : Notifie un changement de valeur de l'opacite au cours de l'animation - ANIMATION_ABORD : Notifie un arrêt prématuré de l'animation Les évènements OPACITY_CHANGED et ANIMATION_ABORD fournissent la valeur courante de l'opacité. Les fonctions applicables à un objet MOpacity sont : - start : démarre l'animation - stop : arrête l'animation - isRunning : détermine si l'animation est en cours Exemple d'utilisation : use MTools; use MTools::GUI::MRect; use MTools::GUI::MGroup; use MTools::Anim::MOpacity; new MTools (800, 600, "Exemple de animation opacity"); new MTools::GUI::MRect(1, 400, 200, 100, 300, -filled=>1, -fillcolor=>"red"); my $group = new MTools::GUI::MGroup (1); new MTools::GUI::MRect ($group, 300, 300, 300, 100, -filled => 1); my $anim = new MTools::Anim::MOpacity(targets => $group, loop => 1, from_opacity => 0, to_opacity => 100, duration => 1 ); $anim->start(); mrun; ________ MPath.pm : MPath permet de réaliser une animation de déplacement suivant un chemin. Le chemin est une suite de segments. L'animation peut porter sur un objet ou un tableau d'objets. Remarque : si le chemin est composé seulement d'un segment, MTranslator.pm suffit. La description du chemin est une liste de points (x, y). L'objet se déplace en ligne droite d'un point à l'autre. La vitesse de déplacement est régulière tout au long du trajet. Elle est déterminée par la durée de l'animation. Le premier point du trajet correspond à l'endroit où se trouve l'objet au départ de l'animation, il sert donc de point de référence. La fonction de création ne nécessite aucun argument. Elle permet de configurer toutes les propriétés comme mconfigure. Les valeurs modifiables par mconfigure sont : - -visible : permet d'activer ou stopper l'animation - path : liste des points (x, y) par lesquels il faut passer - duration : durée de l'animation (défaut : 1s) - loop : indique le caractère répétitif de l'animation (défaut : faux) - targets : objet ou tableau d'objets cible de cette animation. Ces objets doivent disposer d'une fonction "translate". Les évènements émis sont : - ANIMATION_END : Notifie la fin de l'annimation - VALUE_CHANGED : Notifie un changement de position au cours de l'animation - ANIMATION_ABORD : Notifie un arrêt prématuré de l'animation Les évènements VALUE_CHANGED et ANIMATION_ABORD fournissent la valeur courante de la position (x, y) et un vecteur qui donne la direction de déplacement de l'objet (ce vecteur n'est pas proportionnel à la vitesse). La position est un point du chemin. Les fonctions applicables à un objet MPath sont : - start : démarre l'animation - stop : arrête l'animation - isRunning : détermine si l'animation est en cours Exemple d'utilisation : use MTools; use MTools::GUI::MRect; use MTools::Anim::MPath; new MTools (800, 600, "Exemple de animation path"); my $rect = new MTools::GUI::MRect (1, 300, 100, 300, 50, -filled => 1); my $anim = new MTools::Anim::MPath(targets => $rect, loop => 1, duration => 5); $anim->mconfigure(path => [[0, 0], # point de référence [100, 300], [-300, 400], [0, 0]]); # on retourne au point de départ $anim->start(); mrun; __________ MScalor.pm : MScalor permet de realiser une animation de scale (changement de taille). L'animation de changement de taille permet de réaliser une animation homotétique, appliquée à un objet ou à un tableau d'objets. L'homotétie peut utiliser des coefficients différents horizontalement et verticalement. Le changement de taille peut être pour agrandir ou pour diminuer la taille. La fonction de création ne nécessite aucun argument. Elle permet de configurer toutes les propriétés comme mconfigure. Les valeurs modifiables par mconfigure sont : - -visible : permet d'activer ou stopper l'animation - duration : durée de l'animation (défaut : 1s) - loop : indique le caractère répétitif de l'animation (défaut : faux) - targets : objet ou tableau d'objets cible de cette animation. Ces objets doivent disposer d'une fonction "translate". - center_x, center_y : coordonnées du centre de l'homotétie (coordonnées relatives à la fenêtre) - from_x, to_x : valeurs sans dimension pour définir l'homotétie horizontale - from_y, to_y : valeurs sans dimension pour définir l'homotétie verticale Les valeurs qui définissent l'homotétie (from et to) n'ont pas d'unité. Par exemple pour doubler la taille, on peut mettre comme valeur 1 et 2, tout comme on peut mettre 100 et 200. L'utilisation de valeurs de signe opposé a pour effet de retourner l'objet. *** Il y a un problème d'affichage du texte lorsqu'il est retourné horizontalement (il est retourné verticalement à tord). Les évènements émis sont : - ANIMATION_END : Notifie la fin de l'annimation - SCALED : Notifie un changement de taille au cours de l'animation - ANIMATION_ABORD : Notifie un arrêt prématuré de l'animation L'évènement ANIMATION_ABORD fournit la valeur courante du facteur d'homotétie en x et du facteur en y (compris respectivement dans les intervales [from_x, to_x] et [from_y, to_y]). L'évènement VALUE_CHANGED fournit les coefficients d'homotétie comme ANIMATION_ABORD et fournit en plus les coordonnées du centre d'homotétie. Les fonctions applicables à un objet MScalor sont : - start : démarre l'animation - stop : arrête l'animation - isRunning : détermine si l'animation est en cours Exemple d'utilisation : use MTools; use MTools::GUI::MRect; use MTools::GUI::MText; use MTools::Anim::MScalor; new MTools (800, 600, "Exemple de animation scale"); my $rect = new MTools::GUI::MRect (1, 300, 100, 300, 50, -filled => 1); my $message = new MTools::GUI::MText(1, "Texte d'exemple", 100, 100); my $anim = new MTools::Anim::MScalor(targets => [$rect, $message], loop => 1, duration => 2, center_x => 300, # coin haut gauche du center_y => 100, # rectangle from_x => 10, to_x => 14, # +40% en x from_y => 1, to_y => 5); # x5 en y $anim->start(); mrun; ______________ MTranslator.pm : MTranslator permet de realiser une animation de translation d'un ou plusieurs objets, c'est un déplacement suivant un segment. Remarque : dans le cas où le déplacement à effectuer ne peut pas être décrit par un seul segment, il suffit d'utiliser MPath.pm. La translation est décrite par un segment. Les coordonnées du segment n'ont aucun lien avec les coordonnées de l'objet, c'est-à-dire que l'objet ne va pas se déplacer pour aller à l'endroit du segment. Le segment est plutôt à considérer comme un vecteur déplacement. La fonction de création ne nécessite aucun argument. Elle permet de configurer toutes les propriétés comme mconfigure. Les valeurs modifiables par mconfigure sont : - -visible : permet d'activer ou stopper l'animation - from_x, from_y : coordonnées de l'origine du segment (défaut : 0) - to_x, to_y : coordonnées de destination du segment (défaut : 0) - duration : durée de l'animation (défaut : 1s) - loop : indique le caractère répétitif de l'animation (défaut : faux) - targets : objet ou tableau d'objets cible de cette animation. Ces objets doivent disposer d'une fonction "translate". Dans le cas où on souhaite faire un déplacement, de (dx, dy), il suffit de positionner ces valeurs dans to_x et to_y puisque les valeurs par défaut de from_x et from_y sont 0. Les évènements émis sont : - ANIMATION_END : Notifie la fin de l'annimation - MOTION : Notifie un changement de position au cours de l'animation - ANIMATION_ABORD : Notifie un arrêt prématuré de l'animation Les évènements MOTION et ANIMATION_ABORD fournissent la valeur courante de la position (x, y). La position est un point du segment. Les fonctions applicables à un objet MTranslator sont : - start : démarre l'animation - stop : arrête l'animation - isRunning : détermine si l'animation est en cours *** Attention : dans le cas où une cible est de type MMover, le comportement est différent. Voir dans quelle mesure et pourquoi. Exemple d'utilisation : use MTools; use MTools::GUI::MRect; use MTools::Anim::MTranslator; new MTools (800, 600, "Exemple de animation translator"); my $rect = new MTools::GUI::MRect (1, 300, 100, 300, 50, -filled => 1); my $anim = new MTools::Anim::MTranslator(targets => $rect, loop => 1, duration => 2, to_x => 100, to_y => 300); $anim->start(); mrun; 2.6 Les comportements --------------------- Le principe consiste à donner un certains nombre de comportements à des objets graphiques. Par exemple, on à un certain élément dessiné, on va pouvoir ajouter le comportement MMover pour le rendre déplaçable, et le comportement MInertie pour qu'il glisse en fonction de la vitesse à laquelle il a été laché, le comportement MFlicker pour le faire clignoter... ________________________ MAntiRecouvrementItem.pm : ____________________ MAntiRecouvrement.pm : ___________ MFlicker.pm : ___________ MFocuser.pm : ___________ MInertie.pm : _________ MMover.pm : Le composant MMover permet de donner un comportement préhensible à un objet zinc, c'est-à-dire que l'utilisateur va pouvoir "attraper" l'objet pour le déplacer. La zone dans laquelle l'objet peut se déplacer est totalement configurable. La création nécessite les arguments suivants : - src : zone sensible qui va capter les évènements de déplacement - targets : objet ou tableau d'objets à déplacer. Ces objets doivent être équipés de la fonction translate(dx,dy). - button : le bouton souris utilisé pour générer le déplacement, (facultatif, 1 par défaut) - %options : permet de paramétrer les mêmes valeurs qu'un mconfigure. Les valeurs modifiables par mconfigure sont : - x_min, y_min, x_max, y_max : contraintes de l'espace dans lequel peut se deplacer l'objet. Ces variables permettent de gérer facilement le cas simple d'une zone rectangulaire. Pour une gérer une forme personnalisée, il faudra utiliser "allower". - allower(x,y,dx,dy):(cx,cy) : fonction qui permet de gérer des contraintes quelconques sur le déplacement d'un objet. Cette fonction va recevoir en paramètre l'ancienne position de l'objet et le déplacement souhaité. Elle doit retourner un vecteur correspondant à la correction à effectuer sur le deplacement. - x, y : translation de l'objet effectuée par le MMover (la position initiale correspond à (0,0)) - targets : objet ou tableau d'objets à déplacer (fonction translate) - visible : active ou désactive le comportement préhensible Note : pour la gestion des limites de déplacement (par x/y_min/max ou par allower, il ne faut pas oublier que ces limites portent sur le déplacement réalisé par le mover, c'est à dire les valeurs de x et y. Les contraintes ne portent pas sur la position à l'écran du ou des objets déplacés. Néanmoins, il est possible de faire coïncider (x,y) avec un point particulier d'un objet si cela peut rendre les traitements plus faciles. Les évènements émis sont : - PRESSED : Notifie un début (initialisation) d'action de déplacement. Les valeurs fournies sont la position du curseur et la datation de l'évènement. - MOVED : Notifie un déplacement. Les valeurs fournies sont la nouvelle position de ou des objets et la date de l'évènement. Attention, les valeurs sont les nouvelles valeurs pour x et y, donc relatives à la position initiale. On peut toujours accéder aux anciennes valeurs au travers des attributs x et y qui n'ont toujours pas été modifiés. - RELEASED : Notifie une fin d'action de déplacement. Les valeurs fournies sont la position de la souris compensée des non-déplacements des objets en buttée et la date de l'évènement. Les fonctions applicables à un objet MMover sont : - setPos(x, y) : permet de positionner le ou les objets à la position (x, y). Cette position est relative à la valeur courante de (x, y). Les contraintes sur les déplacements ne sont pas prise en compte, aucun évènement n'est émis. - translate(dx, dy, t) : cette fontion permet de demander une translation de (dx, dy). Les contraintes de déplacement sont respectées et l'évènement MOVED est émis. Exemple d'utilisation : use MTools; use MTools::GUI::MCircle; use MTools::Comp::MMover; new MTools (800, 600, "Exemple de comportement mover"); my ($cx, $cy) = (400, 300); new MTools::GUI::MCircle (1, $cx, $cy, 2, -filled => 1); my $disque = new MTools::GUI::MCircle (1, 200, 100, 100, -filled => 1, -fillcolor => "red"); new MTools::Comp::MMover ($disque, $disque, 1, x=>200, y=>100, x_min=>100, y_min=>100, allower => [\&milieu]); sub milieu { my ($x, $y, $dx, $dy) = @_; my $d = sqrt(($x+$dx-$cx)**2 + ($y+$dy-$cy)**2); if ($d < 100) { return ($dx, $dy); # Le déplacement est annulé s'il y chevauchement, # on peut faire plus subtil } else { return (0, 0); } } mrun; __________________ MMultiSelection.pm : _____________ MReconizer.pm : __________ MTremor.pm : ____________ MWritable.pm : MWritable permet d'associer un comportement scriptible à un objet zinc, c'est-à-dire qu'il est possible de faire de l'écriture libre sur l'objet et d'effacer. La création nécessite les arguments suivants : - parent : groupe qui va accueillir les curves dessinées - src : zone sensible qui va capter les évènements de dessin - button : numéro du bouton qui fait passer un mode écriture (paramètre faclutatif, vaut 1 par défaut) - clip : définit la zone dans laquelle l'écriture libre doit être contenue (paramètre faclutatif) Note : il est nécessaire que la zone sensible soit au-dessus afin de capter les évènements. Elle n'a pas besoin d'être visible. Attention : la zone sensible de peut pas avoir "parent" comme parent car elle se retrouverait sous l'objet writable qui est créé dans parent. Les valeurs modifiables par mconfigure sont : - color : couleur d'écriture - writing_mode : ('write' ou 'erase') permet de spécifier le type d'interaction (écriture ou effacement) Les évènements émis sont : - BEGIN_WRITE : Notifie un début d'écriture - WRITE : Notifie l'ajout d'un point en cours d'écriture - END_WRITE : Notifie la fin d'écriture (fin d'une courbe) - ERASE : Notifie la suppression d'une courbe Les deux premiers messages fournissent comme information les coordonnées du point (nouveau ou ajouté). Le message ERASE donne l'indice de la courbe supprimée. Les fonctions applicables à un objet MWritable sont : - beginWrite (x, y) : force un début d'écriture au point (x, y) sans émettre le message BEGIN_WRITE - write (x, y) : force l'écriture jusqu'au point (x, y) sans émettre le message WRITE - endWrite : force la fin d'écriture, sans émettre le message END_WRITE - erase (x, y) : demande un effacement des courbes dans les parages du point (x, y). Les messages ERASE correspondant vont être émis. - deleteCurve (index) : demande la destruction d'une courbe dont l'index est précisé, sans émettre de message ERASE Exemple d'utilisation : use strict; use MTools; use MTools::GUI::MCircle; use MTools::Comp::MWritable; use MTools::GUI::MGroup; new MTools (800, 600, "Exemple d'objet scriptible"); my $writable_area = new MTools::GUI::MGroup (1); new MTools::GUI::MCircle ($writable_area, 400, 300, 200, -filled => 1, -fillcolor => "red"); my $clip_area = new MTools::GUI::MCircle (1, 400, 300, 220, -filled => 1, -visible => 0); my $sensitive_area = new MTools::GUI::MCircle (1, 400, 300, 200, -filled => 1, -visible => 0); my $pen = new MTools::Comp::MWritable ($writable_area, $sensitive_area, 1, $clip_area); my @colors = qw(black green blue yellow); $pen->binding('BEGIN_WRITE', sub { my $color = shift @colors; $pen->mconfigure('color' => $color); push @colors, $color;}); mrun; 2.7 Les inclassables -------------------- Les composants de cette catégorie sont dans le répertoire MTools, à l'exception de WacomAdapter qui est seul dans son répertoire Adapters. __________ MSwitch.pm : Un MSwitch est un objet défini par un ensemble d'états. Un seul état est actif à la fois, l'objet passe donc d'un état à l'autre. Les états sont nommés. Chaque état est décrit par l'ensemble des objets qui doivent être affichés pour réprésenter cet état. Les composants qui servent à décrire un état peuvent être des éléments graphiques, des composants abstraits, des comportements, des objets complexes, des animations... L'activation/désactivation de chaque composant se fait par modification des propriétés visible et sensitive. Exemple : etat1 => [], # état ne comportant aucun composant etat2 => 'fichier_svg.svg#tag_svg', # dans cet état, un objet issu d'un svg va être instancié et affiché etat3 => ['fichier_svg.svg#tag_svg', $obj], # dans cet état, deux objets vont être affichés : l'un est instancié par le MSwitch, l'autre a déjà été créé. *** Je ne sais pas trop dans quel répertoire classer l'objet MSwitch. La création nécessite les arguments suivants : - parent : parent de l'objet MSwitch - %etats : table de hash définissant les états Les valeurs modifiables par mconfigure sont : - state : nom de l'état actif du MSwitch - -visible : détermine si l'état courant est actif. Le changement de valeur permet de rendre visibles ou invisibles les composants qui constituent l'état actif du switch. Les fonctions applicables à un objet MOpacity sont : - setState : $switch->setState('etat') équivalent à $swicth->mconfigure(state=>'etat') Exemple d'utilisation : use MTools; use MTools::MSwitch; use MTools::MTimer; use MTools::Anim::MPath; new MTools (800, 600, "Exemple de switch"); my $mauve = minstance("basique.svg#mauve", 1); rotate($mauve, 45); my $anim = new MTools::Anim::MPath(targets => $mauve, path => [[0, 0], [100, -300], [200, 0], [0, 0]]); # Un des états du switch est utilisé pour activer l'animation. # De la même manière, on peut activer un comportement tel que l'inertie, # anti-recouvrement, sélectionnable... my $switch = new MTools::MSwitch(1, vide => [], partiel => $mauve, anim => ["basique.svg#layer1", $mauve, $anim], complet => ["basique.svg#layer1", $mauve]); $switch->setState("partiel"); my @states = qw(vide partiel anim complet); my $timer = new MTools::MTimer(1000, 1, \&switch); $timer->start(); mrun; sub switch { my $new_state = pop @states; $switch->setState($new_state); unshift @states, $new_state; } _________ MTimer.pm : Le composant MTimer permet de déclencher des actions dans un certain temps, de manière répétitive ou non. La création nécessite les arguments suivants : - timeout : durée associée au timer en ms - repeat : détermine le caractère répétitif du timer (valeur 0 ou 1) - callback : est optionnel et permet d'appeler une callback au déclenchement du timer Les évènements émis sont : - TIME_OUT : ce message est émis à chaque déclenchement du timer, avant l'exécution éventuelle d'une callback. - TIMER_STOPPED : est émis lorsque le timer est stoppé. Les valeurs modifiables par mconfigure sont : - timeout : durée associée au timer en ms - repeat : détermine le caractère répétitif du timer (valeur 0 ou 1) - callback : est optionnel et permet d'appeler une callback au - -visible : cette propriété est définie pour assurer la compatibilité avec les autres objets MTools. Si la valeur est 0 le timer est arrêté (appel de la fonction stop), si la valeur est 1 (appel de la fonction start), le timer est activé. Cette propriété permet notamment d'activer un timer dans un état d'un MSwitch. Les fonctions applicables à un objet MTimer sont : - start : démarre le timer - stop : arrête le timer Remarque : le timer peut être contrôlé par la propriété -visible au lieu d'utiliser start/stop. *** start et stop ne modifient pas la propriété visible, est-ce normal ? *** il n'y a pas de fonction isRunning. Faut-il en ajouter une ? Exemple d'utilisation : use MTools; use MTools::GUI::MRect; use MTools::MTimer; new MTools (800, 600, "Exemple de timer"); my $rect = new MTools::GUI::MRect (1, 300, 100, 300, 50, -filled => 1); my $timer = new MTools::MTimer(200, 1, \&switch); $timer->start(); mrun; sub switch { $rect->mconfigure(-visible => !$rect->mget("-visible")); } ptkdb, MState, MIvy, WacomAdapter 2.8 L'utilisation de TkZinc ---------------------------