aboutsummaryrefslogtreecommitdiff
path: root/doc/manuel_utilisateur.txt
blob: 6fdb202e1e0569e2ecdb6e43e0f2582921a3268a (plain)
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
290
291
292
293
294
295
296
297
298
299
300
301
302
303
304
305
306
307
308
309
310
311
312
313
314
315
316
317
318
319
320
321
322
323
324
325
326
327
328
329
330
331
332
333
334
335
336
337
338
339
340
341
342
343
344
345
346
347
348
349
350
351
352
353
354
355
356
357
358
359
360
361
362
363
364
365
366
367
368
369
370
371
372
373
374
375
376
377
378
379
380
381
382
383
384
385
386
387
388
389
390
391
392
393
394
395
396
397
398
399
400
401
402
403
404
405
406
407
408
409
410
411
412
413
414
415
416
417
418
419
420
421
422
423
424
425
426
427
428
429
430
431
432
433
434
435
436
437
438
439
440
441
442
443
444
445
446
447
448
449
450
451
452
453
454
455
456
457
458
459
460
461
462
463
464
465
466
467
468
469
470
471
472
473
474
475
476
477
478
479
480
481
482
483
484
485
486
487
488
489
490
491
492
493
494
495
496
497
498
499
500
501
502
503
504
505
506
507
508
509
510
511
512
513
514
515
516
517
518
519
520
521
522
523
524
525
526
527
528
529
530
531
532
533
534
535
536
537
538
539
540
541
542
543
544
545
546
547
548
549
550
551
552
553
554
555
556
557
558
559
560
561
562
563
564
565
566
567
568
569
570
571
572
573
574
575
576
577
578
579
580
581
582
583
584
585
586
587
588
589
590
591
592
593
594
595
596
597
598
599
600
601
602
603
604
605
606
607
608
609
610
611
612
613
614
615
616
617
618
619
620
621
622
623
624
625
626
627
628
629
630
631
632
633
634
635
636
637
638
639
640
641
642
643
644
645
646
647
648
649
650
651
652
653
654
655
656
657
658
659
660
661
662
663
664
665
666
667
668
669
670
671
672
673
674
675
676
677
678
679
680
681
682
683
684
685
686
687
688
689
690
691
692
693
694
695
696
697
698
699
700
701
702
703
704
705
706
707
708
709
710
711
712
713
714
715
716
717
718
719
720
721
722
723
724
725
726
727
728
729
730
731
732
733
734
735
736
737
738
739
740
741
742
		NOTE : Ce manuel est en cours de rédaction.
		      Il évolue quotidiennement.

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, 200);
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 clippé
	- 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.

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('<Motion>', [\&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
---------------------

________________________
MAntiRecouvrementItem.pm :


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 :

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

ptkdb, MState, MIvy, WacomAdapter

2.8 L'utilisation de TkZinc
---------------------------