précédent   suivant   sommaire  

3. Les modules d'animation de SMIL 2.0

Rédacteurs
Patrick Schmitz (cogit@ludicrum.org), (Microsoft)
Aaron Cohen (aaron.m.cohen@intel.com), (Intel)
Ken Day (kday@macromedia.com), (Macromedia)

Table des matières

3.1 Introduction

Cette section définit les modules d'animation de SMIL 2.0, qui sont composés d'un module BasicAnimation et d'un module SplineAnimation. Ces modules contiennent des éléments et des attributs pour intégrer une animation sur un plan de montage chronologique et un mécanisme pour composer les effets de plusieurs animations. Puisque ces éléments et ces attributs sont définis dans des modules, les concepteurs d'autres langages balisés peuvent choisir d'inclure ou non cette fonctionnalité dans leurs langages. Les concepteurs de langage qui intègrent d'autres modules SMIL n'ont pas besoin d'inclure les modules d'animation si la fonctionnalité de l'animation n'est pas utile.

Les exemples de ce document qui incluent la syntaxe pour un langage hôte utilisent [SMIL10], [SVG], [HTML4] et [CSS2]. Ces exemples sont donnés comme indication des intégrations possibles avec des langages hôtes variés.

Tandis que ce document définit un ensemble de base des capacités d'animation, il est supposé que les langages hôtes puissent s'appuyer sur le support pour définir des éléments d'animation supplémentaires ou plus spécialisés. Une animation manipule seulement les attributs et les propriétés des éléments cibles, et donc ne requiert aucune connaissance de la sémantique de l'élément cible au-delà de l'information de base.

Ce module dépend du module BasicInlineTiming de SMIL 2.0, utilisant les éléments et les attributs du module de temporisation pour son plan de montage chronologique. Le module BasicInlineTiming est une condition préalable pour n'importe quel profil utilisant une animation SMIL. On suppose que le lecteur a lu et est familier avec le module de temporisation de SMIL 2.0.

Cette section présente d'abord les principes fondamentaux d'une animation dans SMIL 2.0, puis les éléments et attributs du module BasicAnimation et du module SplineAnimation.

3.2 Le modèle d'animation

Cette section décrit la sémantique sous-jacente des modules d'animation de SMIL 2.0. Les éléments spécifiques ne sont pas décrits ici, mais les concepts communs et la syntaxe qui constituent le modèle d'une animation le sont. Les problèmes d'un document sont décrits, ainsi que les moyens de cibler un élément d'une animation. Le modèle d'animation est alors défini par l'accumulation des concepts les plus simples aux concepts les plus complexes : d'abord une durée simple et une fonction d'animation simple f(t), et ensuite l'effet global F(t,u).

3.2.1 La fonction d'animation simple f(t)

L'animation est définie en fonction du temps d'un élément cible (ou plus particulièrement d'un certain attribut de l'élément cible, l'attribut cible). L'animation définit une correspondance temporelle avec les valeurs de l'attribut cible. Cette correspondance prend en compte tous les aspects de la temporisation, ainsi que la sémantique propre à l'animation. La correspondance globale est basée sur une fonction d'animation simple f(t) qui décrit l'animation pendant la durée simple de l'élément. Chaque animation définit une fonction d'animation simple qui produit une valeur pour l'attribut cible pour chaque instant dans la durée simple.

Normatif

Un attribut cible est le nom d'une caractéristique d'un élément cible comme défini dans le langage hôte d'un document.

Ceci peut être, par exemple, un attribut XML contenu dans l'élément ou une propriété CSS qui s'applique sur l'élément. Par défaut, l'élément cible d'une animation sera le parent de l'élément d'animation (un élément d'animation est typiquement un enfant de l'élément cible). Cependant, la cible peut être n'importe quel élément dans le document, identifiée soit par une référence d'ID XML, soit par l'intermédiaire d'une référence de localisation XLink [XLINK].

Comme exemple simple, ce qui suit définit l'animation d'une forme rectangle SVG. Le rectangle évoluera de haut et étroit à bas et large.

<rect ...>
   <animate attributeName="width"	from="10px"  to="100px"
	    begin="0s" dur="10s" />
   <animate attributeName="height" from="100px" to="10px"
	    begin="0s" dur="10s" />
</rect>

Le rectangle commence avec une largeur de 10 pixels qui augmente jusqu'à une largeur de 100 pixels en 10 secondes. Au cours de ces dix mêmes secondes, la hauteur du rectangle décroît de 100 pixels à 10 pixels.

Quand une animation est lancée, elle ne devrait pas réellement changer les valeurs de l'attribut dans le DOM [DOM2]. L'exécution de l'animation devrait conserver une valeur de présentation pour chaque attribut animé, distincte du DOM ou du modèle objet CSS (OM). Si une implémentation ne gère pas un modèle objet, elle devrait conserver la valeur originale comme définie par le document ainsi que la valeur de présentation. La valeur de présentation est reflétée dans la forme affichée du document. Les animations manipulent par conséquent la valeur de présentation, et ne devraient pas affecter la valeur de base exposée par le DOM ou le CSS OM. Ceci est détaillé dans la section « Le modèle en sandwich d'une animation ».

Normatif

La valeur de base d'un attribut cible a au temps t est la valeur de a à laquelle l'animation est appliquée au temps t.

La valeur de présentation d'un attribut cible a au temps t est la valeur de a résultant de l'application de l'animation au temps t.

La valeur de présentation reflète l'effet de l'animation sur la valeur de base. L'effet correspond au changement de la valeur de base de l'attribut cible à un instant donné. Quand une animation se termine, l'effet de l'animation n'est plus appliqué et la valeur de présentation reprend la valeur de base par défaut. L'effet d'animation peut aussi être prolongé jusqu'à geler la dernière valeur pour la durée déterminée par la sémantique de l'attribut fill.

Un élément d'animation définit une fonction d'animation simple qui est évaluée au fur et à mesure des besoins par l'implémentation. Les valeurs résultantes sont appliquées à la valeur de présentation de l'attribut cible. Les fonctions d'animation sont continues dans le temps et peuvent être échantillonnées quelle que soit la cadence appropriée pour le système de rendu. La représentation syntaxique de la fonction d'animation simple est indépendante de ce modèle et peut être décrite de multiples façons. Les éléments d'animation dans cette spécification gèrent une syntaxe pour un jeu de valeurs discrètes ou interpolées, une syntaxe de tracé pour un mouvement basé sur les tracés SVG, une temporisation basée sur des images clés, une interpolation rythmée régulièrement et des variantes de ces fonctionnalités.

Dans l'exemple ci-dessus, la fonction d'animation simple de l'attribut width, spécifiée par 'from="10px" to="100px" ... dur="10s"' est

f(t) = (10 + 90*t/10) px, où t est exprimé en seconde.

Les fonctions d'animation simples peuvent être définies avec des paramètres supplémentaires, ou peuvent être entièrement ou partiellement algorithmiques. Par exemple, une animation "to" interpole à partir de la valeur courante vers la valeur du "to" :

<animate attributeName="top" to="10" dur="2.5s" />

La fonction d'animation est aussi bien fonction de la position courante que du temps:

f(t,u) = (u*(2.5s-t)/2.5s) + 10*(t/2.5s)

Dans tous les cas, l'animation s'exprime en fonction du temps.

Normatif

La fonction d'animation simple définie par un élément d'animation est fonction du temps, f(t), définie pour les temps t, 0<=t<=d, où d est la durée simple de l'élément.

La fonction d'animation simple peut être définie comme une fonction qui dépend de facteurs additionnels au facteur temps. Ceci n'affecte pas le modèle d'animation, en-dehors de l'ajout trivial de paramètres supplémentaires à f(t), comme f(t,u) utilisé dans l'exemple d'animation avec "to" juste au-dessus.

Les animations peuvent être définies soit pour surclasser, soit pour s'ajouter à la valeur de base d'un attribut. Dans ce contexte, la valeur de base peut être la valeur DOM, ou le résultat d'autres animations qui ciblent également le même attribut. Ce concept plus général de valeur de base est appelé la valeur sous-jacente. Les animations qui ajoutent à la valeur sous-jacente sont dites animations additives. Les animations qui surclassent la valeur sous-jacente sont dites non-additives. La fonction d'effet d'animation d'un élément est la fonction qui inclut la modification de la valeur sous-jacente et qui est comptable des répétitions et des gels de l'élément. Comme l'effet d'animation peut être affecté par les répétitions et les gels, il est défini pendant la durée active de l'élément plutôt que pendant sa durée simple.

Les animations peuvent être combinées de certaines façons qui produisent des valeurs intermédiaires en dehors du domaine de l'attribut cible, mais où la valeur de présentation produite est valide. Le type d'un attribut cible correspond à cet ensemble supérieur. Ceci est détaillé dans la section « Le modèle en sandwich d'une animation ».

Normatif

Le type d'un attribut cible a est le type de base dont le domaine de a est un sous-ensemble.

La fonction d'effet d'animation F(t,u) d'un élément d'animation avec une durée active AD est une fonction faisant correspondre le temps t: 0<=t<=AD et les valeurs u du type de l'attribut cible a avec des valeurs du type de a. errata-E31-4

La valeur sous-jacente u d'un attribut cible a d'un élément d'animation au temps t est la valeur de a dont l'effet d'animation est appliqué au temps t.

La fonction d'effet d'animation F(t,u) est généralement définie par rapport à la fonction d'animation simple f(t). La fonction f(t) doit être définie de façon à ce que F(t,u) produise des valeurs d'un type correct.

3.2.2 Récapitulatif des symboles utilisés dans les descriptions sémantiques

a
L'attribut cible d'un élément d'animation.
d
La durée simple d'un élément.
AD
La durée active d'un élément.
t
Un temps. Selon le contexte, t peut être un temps perçu par l'utilisateur, la durée active d'un élément ou sa durée simple.
u
La valeur sous-jacente de l'attribut cible a, en général à un temps spécifique t.
f(t)
La fonction d'animation simple avec des temps appartenant à la durée simple. Notez que, tandis que F(t,u) définit la correspondance pour l'animation entière, f(t) a un modèle simplifié qui gère seulement la durée simple. errata-E31-1 errata-E31-2
F(t,u)
L'effet d'une animation pour tout point appartenant à la durée active de l'animation. Ceci fait correspondre des temps dans la durée active (t: 0<=t<=AD) et une valeur sous-jacente avec une valeur de l'attribut cible. Une valeur de temps de 0 correspond au temps auquel l'animation commence. F(t,u) combine la fonction d'animation simple f(t) avec tous les autres aspects d'une animation et des contrôles de temporisation. errata-E31-3

3.2.3 Le modèle en sandwich d'une animation

Quand une animation est lancée, elle ne change pas réellement les valeurs des attributs dans le DOM. L'exécution de l'animation devrait idéalement conserver une valeur de présentation pour tout attribut cible, distinct du DOM, de CSS ou d'un autre modèle objet (OM) dans lequel l'attribut cible est défini. La valeur de présentation est reflétée dans la forme affichée du document. L'effet des animations consiste à manipuler cette valeur de présentation, et non d'agir sur les valeurs sous-jacentes du DOM ou du CSS OM.

La suite de cette discussion utilise le terme générique OM, tout comme pour le DOM XML [DOM2] que pour le CSS-OM. Si une implémentation ne gère pas un modèle objet, elle devrait idéalement conserver la valeur originale comme définie par le document ainsi que la valeur de présentation ; pour cette section, nous considèrerons que cette valeur originale est équivalente à la valeur OM.

Dans certaines implémentations du DOM, il peut être difficile ou peu pratique de conserver une valeur de présentation comme cela est décrit. Les valeurs CSS devraient toujours être gérées comme cela est décrit, car le CSS-OM fournit un mécanisme pour le faire. Dans les implémentations qui ne gèrent pas les valeurs de présentation distinctes des propriétés générales du DOM XML, l'implémentation doit au moins restaurer la valeur originale quand les animations n'ont plus d'effet.

Le reste de cette discussion suppose l'approche recommandée en utilisant une valeur de présentation distincte.

Le modèle qui rend compte de l'OM et simultanément avec les animations actives ou gelées pour un attribut donné est décrit comme un « sandwich », selon une analogie approximative avec les couches de viande et de fromage d'un « sandwich sous-marin » (un long sandwich fait avec beaucoup de morceaux de viandes et du fromage étalés en couches sur la longueur du pain). Dans cette analogie, le temps est associé à la longueur du sandwich, et chaque animation a sa durée représentée par la longueur de pain concernée par une couche. La valeur de base issue de l'OM occupe la partie inférieure du sandwich. Chaque animation active (ou gelée) est une couche supplémentaire venant par-dessus. Les couches (i.e., les animations) sont placées dans le sandwich en fonction du temps, sur la longueur du pain, et en fonction d'un ordre de priorité, avec les animations qui ont une priorité plus élevée placées au-dessus (i.e., par-dessus) celles qui ont une priorité plus basse. À chaque instant, vous pouvez effectuer une coupe dans le sandwich et voir comment les couches de l'animation sont empilées.

Notez que les animations manipulent la valeur de présentation provenant de l'OM dans lequel l'attribut est défini, et transmettent la valeur résultante à la prochaine couche du document traité. Ceci ne remplace ni surclasse aucune partie de la cascade de traitement normale de l'OM d'un document.

En particulier, animer un attribut défini en XML modifiera la valeur de présentation avant qu'elle ne soit traitée par la feuille de style, en utilisant la valeur du DOM XML comme base. Animer un attribut défini dans un langage de feuille de style modifiera la valeur de présentation transmise pour la suite de la cascade.

Dans CSS2 et le CSS-OM de DOM2, les termes « spécifié », « calculé » et « réel » sont utilisés pour décrire les résultats d'évaluation de la syntaxe, de la cascade et du rendu de la présentation. Quand une animation est appliquée aux propriétés CSS d'un élément particulier, la valeur de base à animer est lue en utilisant la méthode getComputedStyle() (en lecture seule) sur cet élément. Les valeurs produites par l'animation sont écrites dans une feuille de style de surclassement pour cet élément, valeurs qui peuvent être obtenues en utilisant la méthode getOverrideStyle(). Ces nouvelles valeurs affectent alors la cascade et sont reflétées par une nouvelle valeur calculée (et par conséquent, une présentation modifiée). Ceci signifie que l'effet d'animation surclasse toutes les règles de la feuille de style, à l'exception des règles de l'utilisateur avec la propriété !important. Ceci permet aux paramaétrages de style !important de l'utilisateur d'avoir priorité sur les animations, une condition importante pour l'accessibilité. Notez que l'animation peut induire des effets secondaires sur la disposition du document. Voir aussi la section 6.1 vf, la section « Les valeurs spécifiées, calculées et réelles » de [CSS2] et la section 5.2.1 vf, « La feuille de style de surclassement et la feuille de style calculée » de [DOM2CSS].

Dans un OM, la priorité des animations est donnée en fonction du démarrage de chacune. L'animation qui a débuté la première a la priorité la plus basse et l'animation qui a débuté le plus récemment a la priorité la plus haute. Quand deux animations démarrent au même moment, l'ordre d'activation est résolu comme suit :

Notez que si une animation est relancée (voir aussi « La relance des animations »), elle sera toujours placée en haut de la liste des priorités, comme cela l'est pour l'animation la plus récemment lancée. C'est-à-dire, quand une animation redémarre, sa couche se retire du sandwich et se rajoute sur le dessus. En revanche, quand un élément se répète, la priorité n'est pas affectée (le comportement de répétition n'est pas défini comme un redémarrage).

Chaque animation additive ajoute son effet au résultat de toutes les couches inférieures du sandwich. Une animation non-additive surclasse simplement le résultat de toutes les couches inférieures du sandwich. Le résultat final en haut du sandwich est la valeur de présentation qui doit être visible dans le document.

Certains attributs qui gèrent les animations additives ont leurs valeurs définies dans des limites légales (par exemple, un attribut d'opacité peut admettre des valeurs entre 0 et 1). Dans certains cas, une fonction d'animation peut produire des valeurs hors-limites. Il est recommandé que les implémentations gardent les résultats dans l'intervalle légal le plus longtemps possible, avant de les appliquer à la valeur de présentation. Idéalement, les effets de toutes les animations actives ou gelées à un point donné devraient être combinés, avant que tout forçage de valeur ne soit effectué. Bien que des fonctions d'animation individuelles puissent produire des valeurs hors-limites, la combinaison des animations additives peut quand même être légale. Forcer seulement le résultat final et non l'effet de chaque fonction d'animation permet de gérer ces cas. Des résultats intermédiaires peuvent être forcés si nécessaire bien que ce ne soit pas optimal. Le langage hôte doit définir la sémantique de forçage pour chaque attribut qui peut être animé. Comme exemple, ceci est défini pour l'élément animateColor.

Initialement, avant que toute animation pour un attribut donné ne soit active, la valeur de présentation sera identique à la valeur originale donnée dans le document (la valeur OM).

Quand toutes les animations pour un attribut donné sont terminées et que les effets d'animation associés ne sont plus appliqués, la valeur de présentation sera encore égale à la valeur OM. Notez que si une quelconque animation est définie avec fill="freeze", l'effet de l'animation sera appliqué aussi longtemps que l'élément d'animation restera dans l'état de gel, et donc la valeur de présentation continuera de refléter l'effet d'animation. Se référer aussi à la section « Le gel des animations ».

Certaines animations (e.g., animateMotion) cibleront implicitement un attribut, ou probablement plusieurs attributs (e.g., les attributs "posX" et "posY" d'un certain modèle de disposition). Ces animations doivent être combinées avec toute autre animation pour chaque attribut qui est affecté. Ainsi, par exemple une animation animateMotion peut se trouver dans plus d'un sandwich d'animation (selon le modèle de disposition du langage hôte). Pour les éléments d'animation qui ciblent implicitement les attributs, le concepteur d'un langage hôte doit spécifier quels attributs sont implicitement ciblés et l'exécution doit par conséquent combiner les animations pour les attributs respectifs.

Notez que n'importe quelle requête (via les interfaces DOM) sur l'attribut cible renverra la valeur OM et ne réflètera pas l'effet des animations. Notez aussi que la valeur OM peut toujours être changée via les interfaces OM (par exemple, en utilisant un script). Bien qu'il puisse être utile ou souhaitable de permettre un accès à la valeur finale de présentation après que tous les effets des animations sont appliqués, une telle interface n'est pas fournie dans l'animation SMIL. Une future version pourrait y remédier.

Bien qu'une animation ne manipule pas les valeurs OM, l'affichage du document doit refléter les changements sur les valeurs OM. Les langages hôtes peuvent gérer des langages de script qui peuvent manipuler les valeurs des attributs directement dans l'OM. Si une animation est active ou gelée alors que la valeur OM est modifiée, le comportement est dépendant du fait que l'animation est définie comme additive ou non, comme suit : (voir aussi la section « L'animation additive »).

3.2.4 Les éléments d'animation comme « médias continus »

Dans le modèle de temporisation, une animation est considérée comme un média « continu ». Les éléments de l'animation définis dans l'animation de SMIL n'ont pas une durée intrinsèque naturelle, on leur attribut donc la durée intrinsèque indefinite (indéfini).

Ceci a plusieurs conséquences, qui sont notées dans diverses sections plus loin. En particulier, la plupart des éléments d'une animation auront une durée explicite fixée par l'attribut dur, puisqu'une durée finie et connue est requise pour une interpolation.

3.2.5 La fonction d'effet d'animation F(t,u)

Comme décrit plus haut, la fonction d'animation simple f(t) définit l'animation pour la durée simple d. Cependant, la temporisation de SMIL permet à l'auteur de répéter la durée simple. La temporisation de SMIL permet aussi aux auteurs de spécifier si l'animation doit se terminer simplement quand la durée active sera écoulée, ou si elle doit être gelée sur la dernière valeur. L'animation de SMIL spécifie ce que signifie pour une animation d'être gelée. En outre, l'auteur peut spécifier comment chaque animation devra être combinée avec les autres animations et la valeur originale DOM.

Cette section décrit la sémantique de la fonctionnalité supplémentaire, incluant un modèle détaillé pour combiner des animations. Ceci est présenté comme une suite de fonctions basées sur la fonction d'animation simple:

Puisque ces fonctions décrivent l'animation en dehors de la durée simple, elles sont définies pour tout temps t non-négatif. errata-E31-6

La répétition des animations

Comme décrit dans la section « La temporisation d'un intervalle » du module BasicInlineTiming, répéter un élément signifie qu'il est « joué » plusieurs fois en séquence. La période de répétition va de 0 à la durée simple de l'élément. Les animations suivent ce modèle, où « jouer » l'animation signifie appliquer la fonction d'animation simple f(t) à plusieurs reprises.

Normatif

La fonction d'animation répétitive, fr(t), pour toute fonction d'animation simple f(t) est

fr(t) = f( REMAINDER( t, d ) ),

t>=0, d est la durée simple, et REMAINDER( t, d ) est défini par (t - d*floor(t/d)).

Cette formulation suit le modèle exclusif du point final décrit dans la section « La temporisation d'un intervalle ». Au moment où une animation se répète, elle commence à f(0), elle est échantillonnée et appliquée mais n'inclut pas le point final f(d). À la fin de la durée simple, i.e., au début de l'itération suivante, elle recommence à f(0). La valeur f(d) peut en fait ne jamais être appliquée.

Exemples

Dans l'exemple suivant, la fonction d'animation de 2.5 secondes sera répétée deux fois ; la durée active sera de 5 secondes. L'attribut "top" ira de 0 à (presque) 10, reviendra de 0 à 2.5 secondes, et se répètera.

<animate attributeName="top" from="0" to="10" dur="2.5s"
         repeatCount="2"
/>

Dans l'exemple suivant, la fonction d'animation sera répétée entièrement deux fois et puis la première moitié sera répétée une fois de plus; la durée active sera de 7.5 secondes.

<animate attributeName="top" from="0" to="10" dur="3s"
         repeatCount="2.5"
/>

Dans l'exemple suivant, la fonction d'animation sera répétée pour avoir un total de 7 secondes. Elle sera jouée entièrement deux fois, suivi par une fraction de 2 secondes. C'est équivalent à mettre repeatCount à 2.8. La dernière itération (partielle) sera appliquée aux valeurs dans l'intervalle de "0" à "8".

<animate attributeName="top" from="0" to="10" dur="2.5s"
         repeatDur="7s" />

Dans l'exemple suivant, la durée simple est plus longue que la durée spécifiée par l'attribut repeatDur, et donc la durée active coupera en réalité au plus court la durée simple. Cependant, une fonction d'animation utilise toujours la durée simple spécifiée. L'effet de l'animation est d'interpoler la valeur de "top" de 10 à 15, en 5 secondes.

<animate attributeName="top" from="10" to="20" 
         dur="10s" repeatDur="5s"
/>

Notez que si la durée simple n'est pas définie (e.g., elle est indéfinie), le comportement de répétition n'est pas défini (mais repeatDur définit toujours la durée active). Dans l'exemple suivant, la durée simple est indéfinie, et donc repeatCount est en réalité ignoré. Néanmoins, ce n'est pas considéré comme une erreur : la durée active est également indéfinie. L'effet de l'animation est de juste utiliser la valeur pour f(0), plaçant la couleur de remplissage au rouge pour le reste de la durée de l'élément animé.

<animate attributeName="fill" from="red" to="blue" repeatCount="2" />

Dans l'exemple suivant, la durée simple est indéfinie, mais repeatDur détermine toujours la durée active. L'effet de l'animation est de placer la couleur de remplissage à rouge pendant 10 secondes.

<animate attributeName="fill" from="red" to="blue" repeatDur="10s" />

Dans l'exemple suivant, la durée simple est plus longue que la durée spécifiée par repeatDur, et donc la durée active écourtera en réalité la durée simple. Cependant, la fonction d'animation interpole toujours en utilisant la durée simple spécifiée. L'effet de l'animation est d'interpoler la valeur de "top" de 10 à 17, en 7 secondes.

<animate attributeName="top" from="10" to="20" 
         dur="10s" repeatDur="7s"
/>

Le contrôle du comportement d'une animation répétitive - Animation cumulative

L'auteur peut aussi sélectionner si une animation répétitive doit répéter le comportement original pour chaque itération, ou si elle doit le construire à partir des résultats précédents, les accumulant avec chaque itération. Par exemple, un tracé de mouvement qui décrit un arc peut se répéter en se déplaçant le long du même arc à maintes reprises, ou il peut débuter chaque itération à l'endroit où la dernière s'est arrêtée, faisant rebondir l'élément animé à travers la fenêtre. Ceci est appelé une animation cumulative.

Normatif

Chaque élément d'animation doit être défini comme étant soit cumulatif, soit non-cumulatif. Un élément d'animation peut être défini comme cumulatif seulement si l'addition est définie pour l'attribut cible. La fonction d'animation cumulative, fc(t), pour toute fonction d'animation simple f(t) est

fc(t) = fr(t), si l'élément est non-cumulatif.

Si l'élément est cumulatif :

Soit fi(t) la fonction d'animation cumulative pour une itération i donnée.

La première itération f0(t) n'est pas affectée par l'attribut accumulate, et ainsi est la même que la fonction d'animation simple d'origine. Chaque itération ultérieure s'ajoute au résultat des précédentes itérations :

f0(t) = f(t)

fi(t) = (f(d) * i) + f(t - (i*d))   pour tout entier i > 0.

La fonction d'animation cumulative est alors

fc(t) = fi(t), où i = floor(t/d).

Notez que fi+1(t) commence à f(d)*i + f(0). Pour éviter les sauts, les auteurs choisiront typiquement des fonctions d'animation qui commence à 0.

Par exemple, la notation du tracé d'un arc simple (détaillé dans la section « L'élément animateMotion ») peut être utilisée pour décrire un mouvement de rebond :

<img ...>
   <animateMotion path="m 0 0 c 30 50 70 50 100 0 z" dur="5s"
      accumulate="sum" repeatCount="4" />
</img>

L'image se déplace de la position de départ le long de l'arc pendant 5 secondes. Comme l'animation se répète, elle se construit sur la valeur précédente et débute le deuxième arc quand le premier est terminé, comme c'est illustré sur la Figure 1, ci-dessous. De cette façon, l'image « rebondit » à travers l'écran. La même animation pourrait être décrite complètement avec 4 arcs, mais dans le cas général la description de la trajectoire peut être assez grande et lourde à éditer.

Figure 1 - Illustration d'une animation répétitive avec accumulate="sum".

Diagram showing accumulating animation

Figure 1 - Une animation répétitive cumulative. Chaque itération se construit à partir de la précédente.

Notez qu'une animation cumulative contrôle seulement comment une seule animation accumule les résultats de la fonction d'animation simple comme elle se répète. Elle ne contrôle pas spécifiquement comment une animation interagit avec les autres animations pour produire une valeur de présentation. Ce dernier comportement est décrit dans la section « L'animation additive ». De façon similaire, si un élément recommence, l'accumulation de la première exécution n'est pas appliquée à la seconde. Voir « La relance des animations ».

N'importe quel attribut numérique qui supporte l'addition peut gérer une animation cumulative. Par exemple, nous pouvons définir une animation « pulsante » qui agrandira la « largeur » d'un élément SVG <rect> par 100 pixels en 50 secondes.

<rect width="20px"...>
   <animate attributeName="width" dur="5s"
      values="0; 15; 10" additive="sum"
      accumulate="sum" repeatCount="10" />
</rect>

Chaque durée simple augmente la largeur du rectangle de 15 pixels et fini 10 pixels plus large. La forme a une largeur de 20 pixels au début, et après 5 secondes elle a une largeur de 30 pixels. L'animation se répète, et se construit sur les valeurs précédentes. La forme s'agrandira de 45 pixels et ensuite finira avec une largeur de 40 pixels après 10 secondes, et finira éventuellement avec une largeur de 120 (20 + 100) pixels après les 10 répétitions.

Le gel des animations

Les éléments d'animation suivent la définition de l'attribut fill du module de temporisation. Cette section étend cette spécification pour couvrir la sémantique d'animations spécifiques.

Par défaut, quand un élément d'animation se termine, son effet n'est plus appliqué à la valeur de présentation de l'attribut cible. Par exemple, si une animation déplace une image et que l'élément d'animation se termine, l'image « retournera » à sa position d'origine.

<img top="3" ...>
   <animate begin="5s" dur="10s" attributeName="top" by="100"/>
</img>

Comme montré dans la Figure 2, l'image semblera immobile à la valeur top de "3" pendant 5 secondes, puis elle se déplacera vers le bas de 100 pixels en 10 secondes. Quinze secondes après le début du document, l'animation se terminera, l'effet ne sera plus appliqué, et l'image retournera de 103 à 3 pixels où elle a commencé (i.e., à la valeur sous-jacente DOM de l'attribut top).

Figure 2 - Illustration d'une animation sans gel.

Diagram showing an animation with default fill.

Figure 2 - Une animation simple sans gel. Après que l'élément animé est terminé, l'effet de l'animation est annulé.

L'attribut fill peut être employé pour maintenir la valeur de l'animation après l'écoulement de la durée active de l'élément d'animation :

<img top="3" ...>
   <animate begin= "5s" dur="10s" attributeName="top" by="100"
	  fill="freeze" />
</img>

L'animation se termine 15 secondes après le commencement du document, mais l'image reste avec une valeur top de 103 (Figure 3). L'attribut gèle la dernière valeur de l'animation pour la durée de l'effet de gel. Cette durée est contrôlée par le conteneur de temps (pour les détails, voir la section « La temporisation et la synchronisation de SMIL »).

Figure 3 - Illustration d'une animation avec fill="freeze".

Diagram showing a frozen animation.

Figure 3 - Une simple animation gelée. Après que l'élément animé est terminé, l'effet de l'animation est conservé.

Si la durée active écourte la durée simple (en incluant les cas de répétitions partielles), la valeur d'effet d'une animation gelée est définie pour la durée simple écourtée. Dans l'exemple suivant, la fonction d'animation simple se répète entièrement deux fois et puis encore une demi-fois la durée simple. Dans ce cas, la valeur alors gelée sera 53 :

<img top="3" ...>
   <animate begin= "5s" dur="10s" attributeName="top" by="100"
	  repeatCount="2.5" fill="freeze" />
</img>

Figure 4 - Illustration d'une animation combinant les attributs repeat partiel et fill="freeze".

Diagram showing an animation with a partial repeat and freezing.

Dans l'exemple suivant, l'attribut dur est manquant, et donc la durée simple est indéfinie. La durée active est contrainte par la valeur end qui est de 10 secondes. L'interpolation n'est pas définie et la valeur alors gelée sera la valeur de l'attribut from, qui est de 10 :

<animate from="10" to="20" end="10s" fill="freeze" .../> 

Exposons ceci formellement :

Normatif errata-E31-7

La fonction d'animation gelée, ff(t), pour un élément avec une durée active AD, 0<=t<=AD est donnée par

ff(t) = fc(t) pour tout temps t: 0<=t<AD

Si AD n'est pas un multiple de la durée simple d,

ff(AD) = fc(AD).

Si AD est un multiple de d, i.e. AD = d*i pour un certain entier positif i, et l'animation est non-cumulative,

ff(AD) = f(d).

Si AD est un multiple de d, i.e. AD = d*i pour un certain entier positif i, et l'animation est cumulative,

ff(AD) = f(d) * i.

3.2.6 L'animation additive

En plus de répéter et d'accumuler les valeurs d'une seule animation, une animation peut être exprimée comme une variation par rapport à la valeur d'un attribut, plutôt que comme une valeur absolue. Ceci peut être employé dans une animation seule pour modifier la valeur sous-jacente DOM ou pour produire des animations complexes en combinant plusieurs animations simples.

Par exemple, une animation simple de « grossissement » peut augmenter la largeur d'un objet de 10 pixels :

<rect width="20px" ...>
   <animate attributeName="width" from="0px" to="10px" dur="10s"
      additive="sum"/>
</rect>

La largeur est de 20 pixels au début, et augmente à 30 pixels en 10 secondes. Si une animation a été déclarée non-additive, les mêmes valeurs from et to feraient aller la largeur de 0 à 10 pixels en 10 secondes.

De nombreuses animations complexes sont mieux exprimées comme des combinaisons d'animations plus simples. Par exemple, un tracé « vibrant » peut être décrit par un mouvement répété de haut en bas ajouté à n'importe quel autre mouvement :

<img ...>
   <animateMotion from="0,0" to="100,0" dur="10s" />
   <animateMotion values="0,0; 0,5; 0,0" dur="1s"
		  repeatDur="10s" additive="sum"/>
</img>

La fonction d'effet d'animation, , reprend cette sémantique pour un seul élément d'animation:

Normatif

La fonction d'effet d'animation, F(t,u), pour un élément d'animation avec une durée simple x et une durée active y, est une fonction faisant correspondre t, 0<=t<=AD et u, une valeur du type de l'attribut cible de l'animation avec une valeur du même type. errata-E31-5

Chaque élément d'animation doit être défini comme étant soit additif, soit non-additif. Un élément peut être défini comme additif seulement si l'addition est définie pour le type de l'attribut cible.

Si l'animation est additive, F(t,u) = u + ff(t).

Si l'animation est non-additive, F(t,u) = ff(t).

Quand il y a plusieurs animations définies pour un attribut donné qui se superposent à n'importe quel moment, soit les deux s'additionnent, soit une surclasse l'autre. Des animations se superposent quand elles sont toutes deux actives ou gelées au même moment. L'ordonnancement des animations (par exemple, laquelle animation surclasse l'autre) est déterminé par une priorité associée à chaque animation. La priorité des animations est donnée en fonction du moment où chacune commence. La première animation qui a démarré a la priorité la plus basse et celle qui a commencé en dernier a la priorité la plus haute.

Les animations de plus haute priorité qui ne sont pas additives surclasseront toutes les animations précédentes (de priorité plus basse) et fixeront simplement la valeur d'attribut. Les animations qui sont additives s'appliquent (i.e., s'ajoutent) au résultat des précédentes animations activées. Pour les détails de comment les animations sont combinées, voir « Le modèle en sandwich d'une animation ».

Une animation additive est définie pour des attributs numériques et autres types de données pour lesquels une fonction d'addition est définie. Ceci inclut les attributs numériques pour les concepts tels que la position, la largeur et la hauteur, la taille, etc. Ceci inclut également la couleur (se référer à « L'élément animateColor »), et peut inclure d'autres types de données comme ceux spécifiés par le langage hôte.

Il est souvent utile de combiner des animations additives avec un comportement fill, par exemple quand on définit une série de mouvements qui devrait se construire sur une autre :

<img ...>
   <animateMotion begin="0" dur="5s" path="[un certain tracé]"
	   additive="sum" fill="freeze" />
   <animateMotion begin="5s" dur="5s" path="[un certain tracé]"
	   additive="sum" fill="freeze" />
   <animateMotion begin="10s" dur="5s" path="[un certain tracé]"
	   additive="sum" fill="freeze" />
</img>

L'image se déplace le long du premier tracé, puis entame le second tracé à partir de la fin du premier, puis elle suit le troisième tracé à partir de la fin du second et reste au point final.

Bien que de nombreuses animations d'attributs numériques soient additives, ce n'est pas toujours le cas. Comme exemple d'animation qui est définie non-additive, considérez une animation d'extension hypothétique « poursuiteSouris » qui entraîne un objet à suivre la trajectoire de la souris.

<img ...>
   <animateMotion dur="10s" repeatDur="indefinite"
	   path="[un joli tracé]" />
   <poursuiteSouris begin="mouseover" dur="5s"
	   additive="replace" fill="remove" />
</img>

L'animation de poursuite de la souris s'exécute pendant 5 secondes chaque fois que l'utilisateur pointe la souris sur l'image. Elle ne peut pas être additive, ou elle compensera juste le chemin de mouvement de façon étrange. poursuiteSouris a besoin d'ignorer animateMotion alors qu'il est actif. Quand poursuiteSouris se termine, son effet n'est plus appliqué et animateMotion contrôle à nouveau la valeur de présentation pour la position.

En outre, quelques attributs numériques (e.g. un attribut pour un numéro de téléphone) peuvent ne pas gérer correctement l'addition. Spécifier quels attributs supportent une animation additive est laissé au langage hôte. Les types d'attribut pour lesquels l'addition n'est pas définie, tels que les chaînes et les booléens, ne peuvent pas gérer l'animation additive.

L'animation additive et l'animation cumulative

L'attribut accumulate ne devrait pas être confondu avec l'attribut additive. L'attribut additive définit comment une animation est combinée avec d'autres animations et la valeur de base de l'attribut. L'attribut accumulate définit seulement comment la fonction d'animation simple interagit avec elle-même, au cours des itérations de répétition.

Typiquement, les auteurs s'attendent à ce que les animations cumulatives soient additives (comme dans l'exemple décrit pour accumulate ci-dessous), mais ce n'est pas obligatoire. L'exemple suivant est cumulatif mais n'est pas additif.

<img ...>
   <animate dur="10s" repeatDur="indefinite"
	    attributeName="top" from="20" by="10"
	    additive="replace" accumulate="sum" />
</img>

L'animation surclasse n'importe quelle valeur originale qui a été fixée pour "top", et commence à la valeur 20. Elle se déplace vers le bas de 10 à 30 pixels, puis recommence. Elle est cumulative, donc la seconde itération commence à 50 (la valeur 30 de la précédente itération plus la valeur de from, 20) et se déplace à nouveau vers le bas de 10 à 60, et ainsi de suite.

Quand une animation cumulative est aussi définie additive, les deux caractéristiques fonctionnent normalement. L'effet accumulé pour F(t,u) est utilisé comme la valeur de l'animation et est ajouté à la valeur sous-jacente de l'attribut cible. Par exemple :

<img top="10" ... >
  <animate dur="10s" repeatdur="indefinite"

	   attributename="top" from="20" by="10"

	   additive="sum" accumulate="sum" />
</img>

L'animation s'ajoute à la valeur d'origine 10 qui a été fixée pour "top", et commence à la valeur 30. Elle se déplace vers le bas de 10 à 40 pixels, puis recommence. Elle est cumulative, donc la seconde itération commence à 60 (la valeur 40 de la précédente itération plus 20) et se déplace à nouveau vers le bas de 10 à 70, et ainsi de suite.

Se référer également à la section « Le modèle en sandwich d'une animation ».

3.2.7 La relance des animations

Les éléments d'une animation suivent la définition de l'attribut restart du module de temporisation de SMIL. Cette section est descriptive.

Quand une animation redémarre, la sémantique la définissant est que celle-ci se comporte comme si c'était la première fois que l'animation commençait, indépendamment de tout comportement précédent. La fonction d'effet d'animation F(t,u) est définie indépendamment du comportement de l'attribut restart. L'effet d'une animation lancée antérieurement n'est plus appliqué et seule l'effet de l'animation en cours F(t,u) est appliqué.

Si une animation additive est relancée alors qu'elle est active ou gelée, alors l'effet précédent de l'animation (i.e., avant la relance) n'est plus appliqué à l'attribut. Notez en particulier qu'une animation cumulative est définie seulement pendant la durée active d'une animation. Quand une animation est relancée, tout le contexte accumulé est écarté, et l'effet de l'animation F(t,u) débute en s'accumulant à nouveau à partir de la première itération de la durée active relancée.

3.2.8 Le détail de la valeur d'une fonction d'animation

Beaucoup d'animations spécifient la fonction d'animation simple f(t) comme une séquence de valeurs à appliquer dans le temps. Pour certains types d'attributs (e.g., les nombres), il est également possible de décrire une fonction d'interpolation entre les valeurs.

Comme formule simple pour décrire les valeurs, les éléments d'animation peuvent spécifier une valeur from et une valeur to. Si l'attribut prend des valeurs qui gèrent l'interpolation (e.g., un nombre), la fonction d'animation simple peut interpoler des valeurs dans l'intervalle défini par from et to, pendant la durée simple. Une variante utilise une valeur by à la place de la valeur to, pour indiquer un changement additif de l'attribut.

Des formules plus complexes spécifient une liste de valeurs, ou même une description d'un tracé pour un mouvement. Les auteurs peuvent également contrôler la temporisation des valeurs, pour décrire des animations à partir « d'images clés », et même des fonctions plus complexes.

Dans tous les cas, la fonction d'effet d'animation, F(t,u), doit produire des valeurs légales pour l'attribut cible. Trois classes de valeurs sont décrites :

  1. Valeurs scalaires sans unité. Ce sont de simples valeurs scalaires qui peuvent être analysées et fixées sans contraintes sémantiques. Cette classe inclut les entiers (en base 10) et les décimaux (format spécifié par le langage hôte) ;
  2. Valeurs de chaîne. Ce sont de simples chaînes ;
  3. Valeurs abstraites du langage. Ce sont des valeurs comme les valeurs de longueur et d'angle CSS qui ont une analyse plus complexe, mais qui peuvent produire des valeurs pouvant être interpolées.

L'élément animate peut interpoler des valeurs scalaires sans unité, et les deux éléments animate et set peuvent manipuler des valeurs de chaîne sans aucune connaissance sémantique de l'élément ou de l'attribut cible. Les éléments animate et set doivent gérer les valeurs scalaires sans unité et les valeurs de chaîne. Le langage hôte doit définir quelles valeurs abstraites supplémentaires du langage devraient être gérées par ces éléments. Notez que l'élément animateColor gère implicitement les valeurs abstraites des valeurs de couleur et que l'élément animateMotion gère implicitement les valeurs de position et de tracé.

Afin de gérer une interpolation sur les attributs qui définissent des valeurs numériques avec plusieurs sortes d'unités ou de qualificatifs (e.g., "10px", "2.3feet", "$2.99"), une gestion supplémentaire est nécessaire pour analyser et interpoler ces valeurs. Une possibilité est d'exiger que l'environnement de développement de l'animation ait une connaissance intégrée des types de valeur des unités qualifiées. Cependant, ceci viole le principe d'encapsulation et n'évolue pas au-delà de CSS vers les langages XML qui définissent des nouveaux types de valeur d'attribut de cette forme.

L'approche recommandée pour l'implémentation de l'animation dans un environnement hôte donné est de gérer deux interfaces qui font abstraction de la gestion des valeurs abstraites du langage. Ces interfaces ne sont pas spécifiées formellement, mais sont simplement décrites comme suit :

  1. La première interface convertit une chaîne (la valeur de la fonction d'animation) en un nombre sans unité canonique (un entier ou une valeur décimale). Ceci permet aux éléments d'animation d'interpoler entre des valeurs sans exiger de connaissance spécifique des types de données comme une longueur CSS. L'interface exigera probablement une référence à l'attribut cible, pour déterminer les valeurs abstraites légales. Si la chaîne transmise ne peut pas être convertie en un scalaire sans unité, l'élément d'animation traitera les valeurs de la fonction d'animation comme des chaînes et calcMode prendra la valeur "discrete" par défaut.
  2. La seconde interface convertit un nombre canonique sans unité en une valeur de chaîne légale pour l'attribut cible. Celle-ci peut, par exemple, convertir simplement le nombre en une chaîne et ajouter un suffixe pour les unités canoniques. L'élément d'animation utilise ce résultat pour en fait fixer la valeur de présentation.

La gestion de ces deux interfaces assure que le moteur d'une animation n'a pas besoin de reproduire l'analyseur et toute autre logique sémantique supplémentaire associée aux valeurs abstraites du langage.

Ceci n'est pas une tentative pour spécifier comment une implémentation fournit cette gestion, mais plutôt une condition pour la façon dont les valeurs sont interprétées. Les comportements d'une animation ne devraient pas avoir à comprendre ni être capable de conversion entre toutes les unités de longueur CSS, par exemple. En outre, ce mécanisme permet l'application d'animation aux nouveaux langages XML, si l'implémentation d'un langage peut fournir un support d'analyse et de conversion pour les valeurs d'attribut.

Malgré les recommandations ci-dessus, il est parfois utile d'interpoler les valeurs dans un espace d'unité spécifique et d'appliquer le résultat en utilisant les unités spécifiées plutôt que les unités canoniques. Ceci est spécialement vrai pour certaines unités relatives telles que celles définies par CSS (e.g., les unités em). Si une animation spécifie toutes les valeurs dans les mêmes unités, une implémentation peut utiliser une connaissance de la syntaxe associée pour interpoler dans l'espace d'unité et appliquer le résultat dans le sandwich d'animation, en termes d'unités spécifiées plutôt que d'unités canoniques. Comme noté ci-dessus, cette solution ne s'adapte pas bien au cas général. Néanmoins, dans certaines applications (telles que les propriétés CSS), il peut être souhaitable d'adopter cette approche.

L'interpolation et les durées simples indéfinies

Si la durée simple d'une animation est indéfinie (e.g., si la valeur dur n'est pas spécifiée), l'interpolation n'est généralement pas significative. Quand il est possible de définir une fonction d'animation qui n'est pas basée sur une durée simple définie (e.g., certains algorithmes générateurs de nombres aléatoires), la plupart des animations définissent la fonction selon la durée simple. Si une fonction d'animation est définie sur la durée simple et que la durée simple est indéfinie, la première valeur de la fonction d'animation (i.e., f(0)) devrait être utilisée (en fait comme une constante) pour la fonction d'animation.

3.3 Aperçu du module BasicAnimation de SMIL 2.0

Le module BasicAnimation de SMIL 2.0 fournit :

Le module BasicAnimation définit les attributs et éléments en suivant le modèle présenté dans la section « Le modèle d'animation ».

3.4 Les attributs communs du module BasicAnimation de SMIL 2.0

Les éléments du module BasicAnimation ont en commun les attributs utilisés pour identifier l'attribut cible et, moins universellement, les attributs par lesquels les fonctions d'animation sont spécifiées.

3.4.1 La spécification de la cible de l'animation

La cible de l'animation est définie comme un attribut spécifique d'un élément particulier. Les moyens pour spécifier l'attribut cible et l'élément cible sont détaillés dans cette section.

L'attribut cible

L'attribut cible à animer est spécifié avec attributeName. La valeur de cet attribut est une chaîne qui spécifie le nom de l'attribut cible, comme défini dans le langage hôte.

Les attributs d'un élément qui peuvent être animés sont souvent définis par différents langages et/ou dans différents espaces de nommage. Par exemple, dans beaucoup d'applications XML, la position d'un élément (qui est un attribut cible typique) est définie comme une propriété CSS plutôt que comme attributs XML. Dans certains cas, le même nom d'attribut est associé aux attributs ou aux propriétés dans plus d'un langage, ou espace de nommage. Pour permettre à l'auteur de lever l'ambiguïté sur la correspondance du nom, un attribut supplémentaire attributeType est fourni pour spécifier l'espace de nommage voulu.

L'attribut attributeType est facultatif. Par défaut, l'environnement d'exécution de l'animation résoudra les noms selon les règles suivantes : s'il y a un conflit de noms et que attributeType n'est pas spécifié, la liste des propriétés CSS gérées par le langage hôte est examinée (si CSS est géré par le langage hôte) ; si aucune correspondance CSS n'est établie (ou que CSS ne s'applique pas), l'espace de nommage par défaut pour l'élément cible sera mis en correspondance.

Si un attribut cible est défini dans un espace de nommage XML autre que celui par défaut pour l'élément cible, l'auteur doit spécifier l'espace de nommage de l'attribut cible en utilisant le préfixe de l'espace de nommage associé, comme défini dans la portée de l'élément d'animation. Le préfixe est ajouté au début de la valeur de l'attribut attributeName.

Pour plus d'informations sur les espaces de nommage XML, voir [XML-NS].

Attributs de l'attribut cible
 
attributeName
Spécifie le nom de l'attribut cible. Un préfixe xmlns peut être employé pour indiquer l'espace de nommage XML pour l'attribut [XML-NS]. Le préfixe sera interprété dans la portée de l'élément d'animation.
 
attributeType
Spécifie l'espace de nommage dans lequel l'attribut cible et ses valeurs associées sont définis. La valeur de l'attribut est l'une parmi celles qui suivent (les valeurs sont sensibles à la casse) :
CSS
Ceci indique que la valeur de attributeName est le nom d'une propriété CSS, comme défini par le document hôte. Cette valeur d'argument est seulement significative dans les environnements des langages hôtes qui gèrent CSS.
XML
Ceci indique que la valeur de attributeName est le nom d'un attribut XML défini dans l'espace de nommage XML par défaut pour l'élément cible. Notez que si la valeur de attributeName a un préfixe XMLNS, l'implémentation doit utiliser l'espace de nommage associé comme défini dans la portée de l'élément d'animation.
auto
L'implémentation devrait mettre en correspondance attributeName avec un attribut de l'élément cible. L'implémentation doit d'abord rechercher, dans la liste des propriétés CSS, un nom de propriété correspondant, et si aucun n'est trouvé, rechercher l'élément dans l'espace de nommage XML par défaut.
C'est la valeur par défaut.

L'élément cible

Un élément d'animation peut définir l'élément cible d'une animation soit explicitement, soit implicitement. Une définition explicite utilise un attribut pour spécifier l'élément cible. La syntaxe requise est décrite ci-dessous.

Si aucune cible explicite n'est donnée, l'élément cible implicite est l'élément parent de l'élément d'animation dans l'arbre du document. Il est prévu que le cas commun sera qu'un élément d'animation est déclaré comme enfant de l'élément à animer. Dans ce cas, aucune cible explicite n'a besoin d'être donnée.

Si une référence explicite à l'élément cible ne peut pas être résolue (e.g., si un tel élément ne peut être trouvé), l'animation n'a aucun effet. De plus, si l'élément cible (implicite ou explicite) ne gère pas l'attribut cible spécifié, l'animation n'a aucun effet. Voir également la section « La gestion des erreurs de syntaxe ».

Les deux attributs suivants peuvent être employés pour identifier explicitement l'élément cible :

Attributs de l'élément cible
 
targetElement
Cet attribut spécifie l'élément cible à animer. La valeur de l'attribut doit être la valeur d'un attribut identificateur XML d'un élément (i.e., un "IDREF") dans le document hôte. Pour une définition formelle de IDREF, se référer à XML 1.0 [XML10].
href
Cet attribut spécifie l'élément cible à animer. La valeur de l'attribut doit être un localisateur XLink, se rapportant à l'élément cible à animer.

Quand on intègre des éléments d'animation dans le langage hôte, le concepteur du langage devrait éviter d'inclure ces deux attributs. Si cependant, le concepteur du langage hôte choisit d'inclure ces deux attributs dans le langage hôte, alors, quand les deux sont spécifiés pour un élément d'animation donné, l'attribut XLink href a la priorité sur l'attribut targetElement.

L'avantage d'utiliser l'attribut targetElement est la syntaxe simplifiée de la valeur de l'attribut comparé à l'attribut href. L'avantage d'utiliser l'attribut XLink href est qu'il évoluera vers un mécanisme de liens complet dans les futures versions de l'animation de SMIL, et que l'élément d'animation peut être traité par des processeurs XLink génériques. La forme XLink est aussi donnée pour les langages hôtes qui sont conçus pour utiliser XLink pour toutes les références de ce genre. Les deux exemples suivants illustrent ces deux approches.

Cet exemple utilise la syntaxe simplifiée de targetElement:

<animate targetElement="foo" attributeName="bar" .../>

Cet exemple utilise la syntaxe plus souple du localisateur XLink, pour une cible équivalente:

<foo xmlns:xlink="http://www.w3.org/1999/xlink">
   ...
   <animate xlink:href="#foo" attributeName="bar" .../>
   ...
</foo>

Quand on utilise un attribut XLink href sur un élément d'animation, les attributs XLink supplémentaires suivants doivent être définis dans le langage hôte. Ils peuvent être définis dans un DTD, ou le langage hôte peut les exiger dans la syntaxe du document pour gérer les processeurs XLink génériques. Pour plus d'information, se référer à [XLINK].

Les attributs XLink suivants sont requis par la spécification XLink. Les valeurs sont fixées, et ainsi peuvent être spécifiées comme dans un DTD. Tous les autres attributs XLink sont facultatifs et n'affectent pas la sémantique de l'animation de SMIL.

Attributs XLink pour href
 
type
Doit être simple. Identifie le type de XLink utilisé.
actuate
Doit être onLoad. Indique que le lien vers l'élément cible est suivi automatiquement (i.e., sans action de l'utilisateur).
show
Doit être embed. Indique que la référence n'inclut pas de contenu supplémentaire dans le fichier.

Des détails supplémentaires sur la spécification de l'élément cible rapportés au document et au langage hôte sont décrits dans « Les définitions et conditions requises pour les cibles d'animation ».

3.4.2 La spécification de la fonction d'animation simple f(t)

Chaque fonction d'animation définit la valeur de l'attribut à un temps particulier. L'intervalle de temps pour lequel la fonction d'animation est définie est la durée simple. La fonction d'animation ne produit pas des résultats définis pour des temps en dehors de l'intervalle qui va de 0 à la durée simple.

Une animation est décrite soit comme une liste de l'attribut values, soit dans une forme simplifiée qui décrit les valeurs from, to et by. La forme from/to/by est définie dans « Les fonctions d'animation simples définies par from, to et by ».

Attributs de la fonction d'animation simple
values
Une liste, dont le séparateur est le point-virgule, d'une ou plusieurs valeurs, chacune d'elles doit être une valeur légale pour l'attribut spécifié. Les attributs dont les valeurs sont des vecteurs sont gérés en utilisant la syntaxe du vecteur du domaine attributeType. Les blancs de tête et de queue ainsi que les blancs avant et après les séparateurs point-virgules seront ignorés.

Si aucune valeur n'est légale, l'animation n'aura aucun effet (voir aussi « La gestion des erreurs de syntaxe »).

calcMode
Spécifie le mode d'interpolation pour l'animation. Si l'attribut cible ne gère pas l'interpolation linéaire (e.g., pour les chaînes), ou si l'attribut values a seulement une valeur, l'attribut calcMode est ignoré et la valeur d'interpolation discrete est utilisée. L'attribut calcMode peut prendre n'importe laquelle des valeurs suivantes :
discrete
Ceci spécifie que la fonction d'animation passera d'une valeur à la suivante sans aucune interpolation.
linear
Une interpolation linéaire simple entre les valeurs est utilisée pour calculer la fonction d'animation.
C'est la valeur par défaut.
paced
Définit une interpolation pour produire un rythme de changement régulier à travers l'animation. Ceci est seulement géré pour des valeurs qui définissent un intervalle numérique linéaire, et pour lesquelles des notions de « distance » entre les points peuvent être calculées (e.g., position, largeur, hauteur, etc.).

L'animation appliquera les valeurs dans l'ordre pendant le déroulement de l'animation. Pour des animations discrete et linear, les valeurs dans l'attribut values sont régulièrement espacées pendant la durée de l'animation. Pour des animations paced, les valeurs sont espacées afin qu'un taux uniforme de changement soit obtenu.

L'exemple suivant qui utilise la syntaxe de l'attribut values anime la largeur d'une forme SVG pendant 10 secondes, en interpolant d'une largeur de 40 à une largeur de 100 et revenant à 40.

<rect ...>
   <animate attributeName="width" values="40;100;40" dur="10s"/>
</rect>

La fonction d'animation simple pour cet exemple (avec un temps en secondes) est

f(t) = 40 + 60*t/5,       0 <= t < 5, et
f(t) = 100 - 60*(t-5)/5,  5 <= t <= 10.

La fonction d'animation simple définie par les attributs values et calcMode peut être spécifiée formellement :

Normatif errata-E22

Soit i = floor((t*n)/d), d la durée simple de l'élément d'animation, n le nombre d'entrées dans l'attribut values et value[i] la ième entrée (en partant de 0) :

Notez qu'une animation linear ou paced tournera en boucle régulière si la première valeur est répétée en dernière valeur.

Une illustration des modes d'interpolation

Les trois figures 5a, 5b et 5c ci-dessous montre comment la même animation de base changera une valeur dans le temps, selon des modes d'interpolation différents. Tous les exemples sont basés sur l'exemple suivant, mais avec des valeurs différentes pour l'attribut calcMode :

<animate dur="30s" values="0; 6; 5; 11; 10; 16" calcMode="[comme spécfié]" />

Figure 5 - Animation discrete, linear et paced

Diagram of linear interpolation

Figure 5a : Animation discrete par défaut.

calcMode="discrete"

Il y a 6 segments de durée égale : 1 segment par valeur.

Diagram of linear interpolation

Figure 5b : Animation linear par défaut

calcMode="linear"

Il y a 5 segments de durée égale : n-1 segments pour n valeurs.

Diagram of linear interpolation

Figure 5c : Animation paced par défaut

calcMode="paced"

Il y a 5 segments de durée variable : n-1 segments pour n valeurs, calculés pour produire un taux de changement constant dans les valeurs.

Exemples avec calcMode

L'exemple suivant décrit une animation discrete simple :

<animate attributeName="foo" dur="8s"
     values="bar; fun; far; boo" />

La valeur de l'attribut "foo" sera positionnée à chacune des quatre chaînes pendant 2 secondes chacune. Parce que les valeurs de chaîne ne peuvent pas être interpolées, seule une animation discrete est possible ; tout attribut calcMode sera ignoré.

L'exemple suivant décrit une animation linear simple :

<animate attributeName="x" dur="10s" values="0; 10; 100"
     calcMode="linear"/>

La valeur de "x" changera de 0 à 10 dans les 5 premières secondes, et puis de 10 à 100 dans les 5 secondes suivantes. Notez que les valeurs de l'attribut values sont espacées de façon homogène dans le temps ; dans ce cas, le résultat est un changement réel plus important dans la valeur pendant la seconde moitié de l'animation. Remarquez le contraste avec le même exemple modifié pour utiliser une interpolation "paced" :

<animate attributeName="x" dur="10s" values="0; 10; 100"
     calcMode="paced"/>

Pour produire un rythme régulier dans les changements de l'attribut "x", le second segment défini par la liste de l'attribut values obtient la majeure partie de la durée simple : La valeur de "x" changera de 0 à 10 dans la première seconde, et puis de 10 à 100 dans les 9 secondes suivantes. Alors que cet exemple pourrait facilement être réalisé comme une animation from-to sans interpolation paced, de nombreux exemples (tels que les tracés de mouvement) restent beaucoup plus difficiles à construire sans la valeur paced pour calcMode.

3.4.3 La spécification de la fonction d'effet d'animation F(t,u)

Comme décrit dans « La fonction d'effet d'animation F(t,u) », la fonction d'animation simple peut être :

La fonction d'effet d'animation F(t,u) définit la sémantique de ces attributs, et donne des exemples. Cette section donne seulement la syntaxe.

Voir le module BasicInlineTiming pour les définitions des attributs repeatCount, repeatDur et fill.

Le comportement additif et cumulatif des animations à répétition est contrôlé avec les attributs additive et accumulate, respectivement :

Attributs de la fonction d'effet d'animation
accumulate
Contrôle si oui ou non l'animation est cumulative. Peut prendre une des deux valeurs suivantes :
sum
Indique que l'animation est cumulative, i.e., chaque itération après la première se construit sur la dernière valeur de la précédente itération.
none
Indique que l'animation est non-cumulative, i.e., les itérations répètent simplement la fonction d'animation f(t).
C'est la valeur par défaut.
Cet attribut est ignoré si la valeur de l'attribut cible ne gère pas l'addition, ou si l'élément d'animation n'est pas répété.
additive
Contrôle si oui ou non l'animation est additive.
sum
Indique que l'animation est additive, i.e., s'ajoutera à la valeur sous-jacente de l'attribut et à d'autres animations de priorité plus basse.
replace
Indique que l'animation est non-additive, i.e., ignorera la valeur sous-jacente de l'attribut et d'autres animations de priorité plus basse.
C'est la valeur par défaut.
Cet attribut est ignoré si l'attribut cible ne gère pas les animations additives.

3.4.4 Les fonctions d'animation simples spécifiées par from, to et by

Une animation est décrite soit comme une liste de l'attribut values, décrit précédemment, soit dans une forme simplifiée qui utilise les valeurs from, to et by.

Attributs from/to/by pour les fonctions d'animation simples
from
Spécifie la valeur de départ de l'animation. Doit être une valeur légale pour l'attribut spécifié. Ignoré si l'attribut values est spécifié.
to
Spécifie la valeur de fin de l'animation. Doit être une valeur légale pour l'attribut spécifié. Ignoré si l'attribut values est spécifié.
by
Spécifie une valeur de décalage relative à l'animation. Doit être une valeur légale d'un domaine pour lequel l'addition du domaine attributeType est définie et qui produit une valeur dans le domaine attributeType. Ignoré si l'attribut values est spécifié.

La syntaxe plus simple from/to/by prévoit plusieurs variantes. Pour utiliser une de ces variantes, on spécifie soit by soit to ; une valeur from est facultative. Il n'est pas légal de spécifier les deux attributs by et to en même temps ; si les deux sont spécifiés, seul l'attribut to sera pris en compte (by sera ignoré). Les combinaisons des attributs produisent les classes d'animation suivantes.

animation from-to
Spécifier une valeur from et une valeur to définit une animation simple. La fonction d'animation est définie pour commencer à la valeur from et pour terminer à la valeur to.

Normatif : Une animation from-to avec une valeur from à vf et une valeur to à vt est équivalente à la même animation avec une liste de l'attribut values de 2 valeurs, vf et vt.
animation from-by
Spécifier une valeur from et une valeur by définit une animation simple dans laquelle la fonction d'animation est définie pour commencer à la valeur from et pour changer pendant la durée simple selon une variation spécifiée par l'attribut by. Ceci peut seulement être utilisé avec des attributs qui gèrent l'addition (e.g., la plupart des attributs numériques).

Normatif : Une animation from-by avec une valeur from à vf et une valeur by à vb est équivalente à la même animation avec une liste de l'attribut values de 2 valeurs, vf et (vf+vb).
animation by
Spécifier seulement une valeur by définit une animation simple dans laquelle la fonction d'animation est définie pour commencer par la valeur sous-jacente pour l'attribut, en utilisant une variation qui évolue au cours de la durée simple, en commençant par une variation de 0 et en terminant avec la variation spécifiée par l'attribut by. Ceci peut seulement être utilisé avec des attributs qui gèrent les animations additives.

Normatif : Une animation by avec une valeur by à vb est équivalente à la même animation avec une liste de l'attribut values de 2 valeurs, 0 et vb, et additive="sum". Toute autre spécification de l'attribut additive dans une animation by est ignorée.
animation to
Ceci décrit une animation dans laquelle la fonction d'animation est définie pour commencer à la valeur sous-jacente pour l'attribut et pour terminer avec la valeur spécifiée par l'attribut to. En utilisant cette forme, un auteur peut décrire une animation qui commencera avec n'importe quelle valeur courante pour l'attribut, et qui terminera à la valeur to désirée.

Une définition normative d'une animation to est donnée ci-dessous dans « L'animation » To

Exemples

L'exemple "animation from-to" suivant anime la largeur d'une forme SVG durant 10 secondes de 50 à 100.

<rect ...>
   <animate attributeName="width" from="50" to="100" dur="10s"/>
</rect>

L'exemple "animation from-by" suivant anime la largeur d'une forme SVG durant 10 secondes de 50 à 75.

<rect ...>
   <animate attributeName="width" from="50" by="25" dur="10s"/>
</rect>

L'exemple "animation by" suivant anime la largeur d'une forme SVG durant 10 secondes de la largeur d'origine qui est 40 à 70.

<rect width="40"...>
   <animate attributeName="width" by="30" dur="10s"/>
</rect>

Les animations from-to et from-by gèrent également les animations cumulatives, comme dans l'exemple suivant :

<rect width="20px"...>
   <animate attributeName="width" dur="5s" from="10px" to="20px"
      accumulate="sum" repeatCount="10" />
</rect>

Le rectangle grossira de 10 à 20 pixels dans les 5 premières secondes, et ensuite de 20 à 30 dans les 5 secondes suivantes, et ainsi de suite jusqu'à 110 pixels après 10 répétitions. Notez que puisque la valeur par défaut est replace pour additive, la valeur d'origine est ignorée. L'exemple suivant crée explicitement une animation additive :

<rect width="20px"...>
   <animate attributeName="width" dur="5s" from="10px" to="20px"
      accumulate="sum" additive="sum" repeatCount="10" />
</rect>

Les résultats sont les même que précédemment, sauf que toutes les valeurs sont modifiées de 20 par rapport à la valeur originale. Le rectangle est large de 30 pixels après 5 secondes, et de 130 pixels après 10 répétitions.

L'animation to

Une animation to d'un attribut qui gère l'addition est une sorte de mélange d'une animation additive et non-additive. La valeur sous-jacente est employée comme point de départ, comme pour une animation additive, cependant la valeur de fin spécifiée par l'attribut to remplace la valeur sous-jacente, comme si l'animation était non-additive.

L'exemple animation to suivant anime la largeur d'une forme SVG durant 10 secondes de la largeur d'origine qui est 40 à 100.

<rect width="40"...>
   <animate attributeName="width" to="100" dur="10s"/>
</rect>

Puisqu'une animation to a seulement 1 valeur, une animation to "discrete" fixera simplement la valeur de to pendant la durée simple. Dans l'exemple suivant, le rect sera bleu pendant une durée de 10 secondes de l'élément animé.

<rect color="red"...>
   <animate attributeName="color" to="blue" dur="10s" calcMode="discrete"/>
</rect>

La sémantique d'une animation to suit le modèle général d'animation, mais avec quelques cas particuliers. La définition normative donnée ici est parallèle à la définition pour d'autres types d'animations présentées dans la section « Le modèle d'animation ».

Normatif

La fonction d'animation simple f(t,u) pour une animation to avec une valeur to à vt est une interpolation linéaire entre la valeur sous-jacente u et la valeur to :

f(t,u) = (u * (d-t)/d) + (vt * t/d), pour t: 0<=t<=d, où d est la durée simple.

Si aucune autre animation (de priorité plus basse) n'est active ou gelée, ceci définit une interpolation simple. Cependant, si une autre animation manipule la valeur sous-jacente, l'animation to s'ajoutera initialement à l'effet de l'animation de plus basse priorité, et la prédominera de plus en plus qu'on se rapprochera de la fin de la durée simple, en la surclassant éventuellement complètement. La valeur de f(t,u) à la fin de la durée simple est juste la valeur to.

Répéter des animations to est la même chose que de répéter d'autres animations :

Normatif

La fonction d'animation répétée, fr(t,u), a la définition standard :
fr(t,u) = f( REMAINDER(t,d), u ).

Puisqu'une animation to est définie selon les valeurs absolues de l'attribut cible, une animation cumulative n'est pas définie:

Normatif

La fonction d'animation cumulative, fc(t), pour une animation to est
fc(t,u) =fr(t,u).

Une animation to gelée prend la valeur au moment où elle est gelée, en masquant les changements ultérieurs de la valeur sous-jacente. Ceci correspond à la prédominance de la valeur to à la fin de la durée simple. Même si d'autres animations, de priorité plus basse, sont actives alors qu'une animation to est gelée, la valeur ne change pas.

Normatif

La fonction d'animation gelée, ff(t), pour une animation to est
ff(t,u) = fc(t,u), si l'animation n'est pas gelée au temps t, et

ff(t,u) = vf, si l'animation est gelée au temps t, où vf est la valeur de ff(t,u) au moment où l'animation a été gelée.

Par exemple, considérez

<rect width="40"...>
   <animate attributeName="width" to="100" dur="10s" repeatCount="2.5" fill="freeze"/>
</rect>

La largeur s'animera de 40 à 100 pixels dans les 10 premières secondes, répètera de 40 à 100 dans les 10 secondes suivantes, ira de 40 à 70 dans les dernières 5 secondes, et gèlera à 70.

Une animation to définit son propre type de sémantique additive, donc l'attribut additive est ignoré.

Normatif

La fonction d'effet d'animation, F(t,u) pour une animation to est
F(t,u) = ff(t,u).

De multiples animations to pourront également se combiner selon cette sémantique. Pendant la progression de l'animation, l'animation de plus haute priorité aura un effet de plus en plus important et le résultat final sera de placer l'attribut à la valeur finale de l'animation to de plus haute priorité.

Pour avoir un exemple d'animation to additive, considérez les deux animations additives suivantes. La première, une animation by applique une variation à l'attribut "x" de 0 à -10. La seconde, une animation to s'anime jusqu'à une valeur finale de 10.

 <foo x="0" ...>
    <animate id="A1" attributeName="x"
	by="-10" dur="10s" fill="freeze" />
    <animate id="A2" attributeName="x" 
	to="10"  dur="10s" fill="freeze" />
 </foo>

La valeur de présentation pour "x" dans l'exemple ci-dessus, pendant 10 secondes, est présentée dans la Figure 6 ci-dessous. Ces valeurs sont calculées simplement en utilisant la formule décrite ci-dessus. Notez que la valeur de F(t,u) pour A2 est la valeur de présentation de "x", puisque A2 est l'animation de plus haute priorité.

Figure 6 - Exemple d'effet avec une animation to additive

Temps F(t,u) pour A1 F(t,u) pour A2
 0 0 0
 1 -1 0.1
 2 -2 0.4
 3 -3 0.9
 4 -4 1.6
 5 -5 2.5
 6 -6 3.6
 7 -7 4.9
 8 -8 6.4
 9 -9 8.1
10 -10 10

3.5 Les éléments du module BasicAnimation de SMIL 2.0

Le module BasicAnimation de SMIL définit quatre éléments : animate, set, animateMotion et animateColor.

3.5.1 L'élément animate

L'élément animate introduit une animation d'attribut générique qui exige peu ou pas de compréhension sémantique de l'attribut à animer. Il peut animer des scalaires numériques aussi bien que des vecteurs numériques. Il peut aussi animer un attribut non-numérique au travers un ensemble discret de valeurs. L'élément animate est un élément vide ; il ne peut pas avoir d'éléments enfants.

Cet élément gère les attributs from/to/by et évalue les descriptions de la fonction d'animation, aussi bien que tous les modes de calcul. Il supporte tous les attributs de temporisation décrits. Ceux-ci sont tous décrits dans des sections respectives au-dessus.

Attributs de l'élément
attributeName et
attributeType
L'attribut à animer. Voir « L'attribut cible ». attributeName est obligatoire ; attributeType est facultatif.
targetElement,
href,
actuate,
show et
type
L'élément cible. Voir « L'élément cible ». Tous sont facultatifs.
 
from,
to,
by,
values,
calcMode,
accumulate et
additive
 
Spécifient la fonction et l'effet d'animation. Voir « La spécification de la fonction d'animation simple f(t) » et « La spécification de la fonction d'effet d'animation F(t,u) ».

De nombreux exemples sont fournis plus haut, ainsi que les définitions normatives de la sémantique de tous les attributs gérés par animate.

3.5.2 L'élément set

L'élément set fournit un moyen simple pour régler la valeur d'un attribut pour une durée spécifiée. Comme avec tous les éléments d'animation, ceci manipule seulement la valeur de présentation, et quand l'animation se termine, l'effet n'est plus appliqué. C'est à dire, l'élément set ne fixe pas la valeur de l'attribut définitivement.

L'élément set gère tous les types d'attribut, incluant ceux qui ne peuvent pas être interpolés raisonnablement et ceux qui gèrent plus judicieusement une sémantique de simple paramétrage de valeur (e.g., des chaînes et des valeurs booléennes). L'élément set est non-additif. Les attributs additive et accumulate ne sont pas autorisés et seront ignorés s'ils sont spécifiés.

L'élément set gère tous les attributs de temporisation pour spécifier la durée simple et la durée active. Cependant, les attributs repeatCount et repeatDur affecteront juste la durée active de set, en prolongeant l'effet de set (étant donné que « répéter » une opération statique n'a pas grand sens). Notez que d'utiliser fill="freeze" avec set aura le même effet que de définir la temporisation alors que la durée active est indéfinie.

L'élément set gère un jeu d'attributs plus restreint que l'élément animate. Seule une valeur est spécifiée et ni contrôle d'interpolation ni animation additive ou cumulative ne sont gérés :

Attributs de l'élément
attributeName et
attributeType
L'attribut à animer. Voir « L'attribut cible ». attributeName est obligatoire ; attributeType est facultatif.
 
targetElement,
href,
actuate,
show et
type
L'élément cible. Voir « L'élément cible ». Tous sont facultatifs.
to
Spécifie la valeur de l'attribut cible pendant la durée active de l'élément set. La valeur de l'argument doit correspondre au type de l'attribut cible.

Normatif

La fonction d'animation simple définie par un élément set est
f(t) = v

v est la valeur de l'attribut to.

L'élément set est non-cumulatif et non-additif.

Exemples

L'exemple suivant change la largeur du liseré d'un rectangle SVG de la valeur d'origine à une largeur de 5 pixels. L'effet débute à 5 secondes et dure 10 secondes, après lequel la valeur d'origine sera à nouveau utilisée.

<rect ...>
   <set attributeName="stroke-width" to="5px"
	    begin="5s" dur="10s" fill="remove" />
</rect>

L'exemple suivant donne à l'attribut class de l'élément text la valeur de chaîne "illumine" quand la souris arrive sur l'élément et retire l'effet quand la souris s'en écarte.

<text>Ce texte va s'illuminer si la souris le survole...
   <set attributeName="class" to="illumine"
	    begin="mouseover" end="mouseout" />
</text>

3.5.3 L'élément animateMotion

L'élément animateMotion mettra un élément en mouvement le long d'un tracé. L'élément extrait la notion de mouvement et de position au travers d'une variété de mécanismes de disposition - le langage hôte définit la modèle de disposition et doit spécifier la sémantique précise de la position et du mouvement. Le tracé peut être décrit de deux façons :

Toutes les valeurs doivent être des couples de valeurs x, y. Chaque valeur x et y peuvent spécifier n'importe quelle unité gérée pour le positionnement de l'élément par le langage hôte. Le langage hôte définit les unités par défaut. De plus, le langage hôte définit le point de référence pour positionner un élément. C'est le point dans l'élément qui est aligné à la position décrite par l'animation de mouvement. Le point de référence se place par défaut dans certains langages dans le coin supérieur gauche de la boîte contenant l'élément ; dans d'autres langages, le point de référence peut être implicite, ou peut être spécifié pour un élément.

La syntaxe pour le couple de valeurs x, y est :

coordinate-pair ::= ( coordinate comma-wsp coordinate ) errata-E06
coordinate	::= num
num		 ::= Number

Les valeurs de coordinate sont séparées par au moins un espace ou une virgule. Des espaces supplémentaires autour du séparateur sont autorisés. Les valeurs de coordinate doivent être définies comme un certain type de nombre dans le langage hôte.

Les attributs attributeName et attributeType ne sont pas utilisés avec animateMotion, car le(s) attribut(s) de position sont définis par le langage hôte. Si la position est exposée comme un attribut ou des attributs qui peuvent aussi être animés (e.g., comme "top" et "left", ou "posX" et "posY"), les implémentations doivent combiner les animations animateMotion avec les autres animations qui manipulent des attributs de position individuels. Voir également « Le modèle en sandwich d'une animation ».

Si aucun des attributs from, to, by et values n'est spécifié, l'animation n'aura aucun effet.

Le mode de calcul par défaut (calcMode) pour l'élément animateMotion est paced. Ceci produira un mouvement à vitesse constante le long du tracé spécifié. Notez que tant que les éléments animateMotion peuvent être additifs, l'addition de deux ou plusieurs animations paced (à vitesse constante) peuvent ne pas se solder par une animation combinée à vitesse constante.

Attributs de l'élément
 
targetElement,
href,
actuate,
show et
type
L'élément cible. Voir « L'élément cible ». Tous sont facultatifs.
from,
to,
by,
values,
accumulate et
additive
 
Spécifient la fonction et l'effet d'animation. Voir « La spécification de la fonction d'animation simple f(t) » et « La spécification de la fonction d'effet d'animation F(t,u) ».
calcMode
Défini comme ci-dessus dans « La spécification de la fonction d'animation simple f(t) », mais notez que la valeur de l'attribut calcMode pour animateMotion est paced par défaut. Ceci produira un mouvement à vitesse constante.

L'utilisation de la valeur linear pour l'attribut calcMode avec plus de 2 points décrits dans l'attribut values peut conduire à un mouvement à vitesse variable. L'attribut calcMode avec la valeur linear spécifie que le temps est divisé de façon homogène parmi les segments définis par values. L'utilisation de la valeur linear ne spécifie pas que le temps soit divisé de façon homogène selon la distance décrite par chaque segment.

Pour un mouvement à vitesse constante, l'attribut calcMode devrait être mis à paced.

origin
Spécifie l'origine du mouvement de l'animation. Les valeurs et la sémantique de cet attribut sont dépendantes du modèle de disposition et de positionnement du langage hôte. Dans certains langages, il peut y avoir seulement une option, default. Cependant, dans le positionnement CSS par exemple, il est possible de spécifier un tracé de mouvement relatif au bloc conteneur ou à la position de la disposition de l'élément. Il est souvent utile de décrire un mouvement relativement à la position de l'élément tel qu'il est disposé (e.g., à partir de la gauche hors écran vers la position de disposition, spécifiée par from="(-100,0)" et to="(0,0)"). Les auteurs doivent être capables de décrire un mouvement de cette manière, aussi bien que relativement au bloc conteneur. L'attribut origin gère cette distinction. Néanmoins, parce que le langage hôte définit le modèle de disposition, il doit également spécifier le comportement « par défaut », aussi bien que toutes les valeurs d'attribut supplémentaires qui sont gérées.
Notez que la définition du modèle de disposition dans le langage hôte spécifie si les conteneurs ont des limites, ou non, et le comportement quand un élément est déplacé hors des limites du conteneur de disposition. Dans CSS2 [CSS2], par exemple, ceci peut être contrôlé par la propriété "clip".
Notez que pour une animation additive, la distinction d'origine n'est pas significative. Cet attribut s'applique seulement quand l'attribut additive a la valeur replace.

3.5.4 L'élément animateColor

L'élément animateColor spécifie une animation d'un attribut de couleur. Le langage hôte doit spécifier ces attributs qui décrivent les valeurs de couleur et qui peuvent gérer une animation de couleur.

Toutes les valeurs doivent représenter des valeurs de couleur [sRGB]. La syntaxe des valeurs autorisées pour les valeurs d'attribut est définie par le langage hôte.

L'interpolation est définie en fonction de chaque canal de couleur.

Attributs de l'élément
attributeName et
attributeType
L'attribut à animer. Voir L'attribut cible. attributeName est obligatoire ; attributeType est facultatif.
targetElement,
href,
actuate,
show et
type
L'élément cible. Voir « L'élément cible ». Tous sont facultatifs.
 
from,
to,
by,
values,
calcMode,
accumulate et
additive
 
Spécifient la fonction et l'effet d'animation. Voir « La spécification de la fonction d'animation simple f(t) » et « La spécification de la fonction d'effet d'animation F(t,u) ».

Les valeurs des attributs from/to/by et values peuvent spécifier une gamme de valeurs négatives ou hors gamut pour les couleurs. La fonction définie par un animateColor individuel peut produire une gamme de valeurs négatives ou hors gamut. L'implémentation doit corriger la valeur de présentation résultante, pour que celle-ci soit légale dans l'espace de couleur de destination (affiché). Cependant, comme décrit dans « Le modèle en sandwich d'une animation », l'implémentation devrait seulement corriger le résultat final combiné de toutes les animations pour un attribut donné, et ne devrait pas corriger l'effet des animations individuellement.

Les valeurs sont corrigées en les « forçant » dans l'intervalle correct. Des valeurs plus petites que la valeur minimale autorisée sont ramenées à la valeur minimale (généralement 0, mais pas nécessairement pour certains profils de couleur). Des valeurs plus grandes que la valeur maximale définie sont ramenées à la valeur maximale (définie par le langage hôte).

Notez que les valeurs des couleurs sont corrigées en les contraignant dans le gamut de l'espace de couleurs de destination (affiché). Certaines implémentations peuvent être incapables de traiter des valeurs qui sont en dehors de l'espace de couleurs source (sRGB) et doivent par conséquent en effectuer le forçage dans l'espace de couleurs source, puis les convertir dans l'espace de couleurs de destination et les forcer dans le gamut. L'essentiel est de faire la distinction entre le gamut de source et celui de destination ; de forcer aussi tard que possible et de réaliser que certains appareils, tels que les imprimantes à jet d'encre qui sont apparemment des appareils RGB, ont des gamuts non-cubiques.

Note aux développeurs :
Quand animateColor est spécifié comme une animation to, la fonction d'animation devrait supposer une distance Euclidienne du cube RGB où les variations doivent être calculés. Voir également « La spécification de la fonction d'animation simple f(t) » et « Les fonctions d'animation simples spécifiées par from, to et by ». Similairement, quand l'attribut calcMode a la valeur paced pour l'élément animateColor, la fonction d'animation devrait supposer une distance Euclidienne du cube RGB pour calculer la distance et le rythme.

3.6 Le détail du module BasicAnimation de SMIL 2.0

3.6.1 Les conditions requises pour l'intégration de BasicAnimation

Cette section décrit ce qu'un concepteur de langage doit effectivement faire pour spécifier l'intégration de l'animation de SMIL dans un langage hôte. Ceci inclut les définitions de base et les contraintes sur l'animation.

En plus des exigences listées dans cette section, celles listées dans « Les conditions requises communes pour l'intégration d'une animation » doivent être satisfaites.

Les définitions et conditions requises pour les cibles d'animation

La spécification de l'élément cible

Le concepteur du langage hôte doit décider s'il gère l'attribut targetElement ou les attributs XLink pour spécifier l'élément cible. Notez que si la syntaxe XLink est utilisée, le concepteur du langage hôte doit décider comment indiquer l'espace de nommage XLink pour les attributs associés. L'espace de nommage peut être donné dans un DTD ou le concepteur du langage peut exiger des noms d'attributs qualifiés (qname) qu'ils indiquent l'espace de nommage XLink pour les attributs. Les attributs XLink requis ont des valeurs fixées et donc peuvent aussi être spécifiés dans un DTD, ou peuvent être requis par les éléments d'animation. Les concepteurs de langage hôte peuvent exiger que les attributs XLink facultatifs soient spécifiés. Ces décisions sont laissées au concepteur du langage hôte - les détails de la syntaxe des attributs XLink n'affectent pas la sémantique d'animation de SMIL.

En général, les éléments cibles peuvent être n'importe quel élément du document. Les concepteurs de langage hôte doivent spécifier toutes les exceptions à ceci. On encourage les concepteurs de langage hôte à ne pas autoriser des éléments d'animation à cibler des éléments hors du document dans lequel l'élément d'animation est défini. La syntaxe XLink de l'élément cible pourrait le permettre, mais la temporisation SMIL et la sémantique de l'animation ne sont pas définis dans cette version de l'animation de SMIL.

Les questions liées à l'attribut cible

Les définitions de ce module peuvent être employées pour animer n'importe quel attribut de n'importe quel élément d'un document hôte. Cependant, il est prévu que les concepteurs de langage hôte intégrant l'animation de SMIL puissent choisir de limiter les éléments et attributs capables de gérer une animation. Par exemple, un langage hôte peut choisir de gérer l'animation de l'attribut language d'un élément script. Un langage hôte qui inclut une spécification pour une fonctionnalité DOM pourrait limiter une animation aux attributs qui peuvent légalement être modifiés au travers du DOM.

N'importe quel attribut de n'importe quel élément qui n'est pas expressément exclu d'une animation par le langage hôte peut être animé, aussi longtemps que le type de données sous-jacent (comme défini par le langage hôte pour l'attribut) gère des valeurs discrètes (pour une animation discrète) et/ou l'addition (pour une animation interpolée, additive ou cumulative).

Toutes les contraintes sur l'animation doivent être décrites dans la spécification du langage hôte ou dans un schéma approprié, puiqu'un DTD seul ne peut pas raisonnablement exprimer ceci.

Le langage hôte doit définir quelles valeurs abstraites du langage devraient être manipulées pour les attributs animés. Par exemple, un langage hôte qui incorpore CSS peut exiger que les valeurs de longueur CSS soient gérées. Ceci est précisé dans « Le détail de la valeur d'une fonction d'animation ».

Le langage hôte doit donner l'interprétation des valeurs relatives. Par exemple, si une valeur est spécifiée comme un pourcentage de la taille d'un conteneur, le langage hôte doit spécifier si cette valeur sera interprétée dynamiquement en fonction d'une animation de la taille du conteneur.

Le langage hôte doit spécifier la sémantique de forçage des valeurs pour les attributs. Le langage doit donner tous les intervalles définis des valeurs et indiquer comment les valeurs hors de l'intervalle seront traitées.

Le langage hôte doit spécifier les formats reconnus pour les valeurs des attributs numériques. Ceci inclut les valeurs entières et décimales. Dans un minimum raisonnable, on encourage les concepteurs de langage hôte à gérer le format décrit dans la section 4.3.1 vf, « Les entiers et les nombres réels », de [CSS2].

L'intégration de la fonctionnalité animateMotion

La spécification du langage hôte doit définir quels éléments peuvent être la cible de animateMotion. De plus, la spécification du langage hôte doit décrire le modèle de positionnement des éléments et doit décrire le modèle de animateMotion dans ce contexte (i.e., la sémantique de la valeur default de l'attribut origin doit être définie). S'il y a différentes façons de décrire la position, les valeurs des attributs supplémentaires de l'attribut origin devraient être définies pour permettre aux auteurs de contrôler le modèle de positionnement.

3.6.2 La définition du type de document (DTD) pour le module BasicAnimation

Voir le DTD complet pour les modules d'animation de SMIL.

3.7 Aperçu du module SplineAnimation de SMIL 2.0

Cette section définit la fonctionnalité du module SplineAnimation de SMIL 2.0. Ce module ajoute des attributs pour une interpolation spline et pour un espacement irrégulier des points dans le temps. Ces attributs peuvent être utilisés dans les éléments animate, animateMotion et animateColor.

3.7.1 Les attributs du module SplineAnimation de SMIL 2.0

Le mode de calcul de la fonction d'animation spline

Le module SplineAnimation étend les modes de calcul discrete, linear et paced du module BasicAnimation, en fournissant un contrôle supplémentaire sur l'interpolation et la temporisation :

Attributs du mode de calcul
calcMode
En plus des valeurs discrete, linear et paced du module BasicAnimation, le module AdvanceAnimation gère la valeur spline errata-E12
spline
Interpole une valeur de la liste de l'attribut values avec la suivante selon une fonction temporelle définie par une spline de Bézier cubique. Les points de la spline sont définis dans l'attribut keyTimes, et les points de contrôles pour chaque intervalle sont définis dans l'attribut keySplines.

L'utilisation de discrete pour calcMode avec une spécification path est autorisée, mais sautera simplement l'élément cible de point en point. Les temps sont dérivés des points de la spécification path, comme décrit dans l'attribut path, immédiatement ci-dessous.

keyTimes
Une liste, dont le séparateur est le point-virgule, de valeurs temporelles utilisées pour contrôler le rythme de l'animation. Chaque temps dans la liste correspond à une valeur de la liste de l'attribut values et définit quand la valeur devrait être utilisée dans la fonction d'animation. Chaque valeur temporelle de la liste de l'attribut keyTimes est spécifiée comme une valeur décimale entre 0 et 1 (inclus), représentant un décalage proportionnel dans la durée de l'élément animation.

Si une liste keyTimes est spécifiée, il doit y avoir exactement autant de valeur dans la liste de l'attribut keyTimes que dans la liste de l'attribut values.

Si l'attribut keyTimes n'est pas spécifié, la durée simple est divisée en segments égaux comme décrit dans « La fonction d'animation simple f(t) ».

Chaque valeur temporelle successive doit être supérieure ou égale à la valeur temporelle précédente.

La sémantique de la liste keyTimes dépend du mode d'interpolation :

  • Pour une animation linéaire ou spline, la première valeur temporelle de la liste doit être 0 et la dernière doit être 1. La valeur keyTime associée à chaque valeur définit quand la valeur est fixée ; les valeurs sont interpolées entre les valeurs keyTimes.
  • Pour une animation discrète, la première valeur temporelle de la liste doit être 0. Le temps associé à chaque valeur définit quand la valeur est fixée ; la fonction d'animation utilise cette valeur jusqu'au prochain temps défini dans keyTimes.

Si le mode d'interpolation est paced, l'attribut keyTimes est ignoré.

S'il y a des erreurs dans la spécification keyTimes (mauvaises valeurs, trop ou pas assez de valeurs), l'animation n'aura aucun effet.

Si la durée simple est indéfinie et que le mode d'interpolation est linear ou spline, toutes les spécifications keyTimes seront ignorées.

keySplines
Un jeu de points de contrôle de Bézier associés à la liste keyTimes, définissant une fonction de Bézier cubique qui contrôle le rythme d'intervalle. La valeur de l'attribut est une liste, dont le séparateur est le point-virgule, de descriptions de point de contrôle. Chaque description de point de contrôle est un jeu de quatre valeurs décimales : x1 y1 x2 y2, décrivant les points de contrôle de Bézier pour un segment temporel. Les valeurs keyTimes qui définissent le segment associé sont les « points d'ancre » de Bézier et les valeurs keySplines sont les points de contrôle. Par conséquent, il doit y avoir un jeu de points de contrôle de moins pour l'attribut keySplines qu'il n'y a de keyTimes.

Les valeurs doivent toutes être dans l'intervalle qui va de 0 à 1.

Cet attribut est ignoré à moins que calcMode ne soit fixé à spline.


S'il y a des erreurs dans la spécification keySplines (mauvaises valeurs, trop ou pas assez de valeurs), l'animation n'aura aucun effet.

Cette sémantique (la durée est divisée en n-1 périodes égales) s'applique aussi bien quand l'attribut keySplines est spécifié, mais pas keyTimes. Les temps associés aux valeurs keySplines sont déterminés comme décrit ci-dessus.

La syntaxe des ensembles des points de contrôle des listes keySplines est celle-ci :

control-pt-set ::= ( fpval comma-wsp fpval comma-wsp fpval comma-wsp fpval )

En utilisant :

fpval	       ::= Nombre décimal
S	       ::= spacechar*
comma-wsp      ::= S (spacechar|",") S
spacechar      ::= (#x20 | #x9 | #xD | #xA)

Les valeurs de point de contrôle sont séparées par au moins un espace ou une virgule. Des espaces supplémentaires autour du séparateur sont autorisés. La syntaxe admise pour les nombres décimaux doit être définie dans le langage hôte.

Si les valeurs de l'argument de keyTimes ou keySplines ne sont pas légales (en incluant pas assez ou trop de valeurs pour l'un ou l'autre attribut), l'animation n'aura aucun effet (voir également « La gestion des erreurs de syntaxe »).

Dans les valeurs des attributs calcMode, keyTimes et keySplines, les les blancs de tête et de queue ainsi que les blancs avant et après les séparateurs point-virgules seront ignorés.

Exemples d'utilisation avancée avec calcMode

Une animation discrète peut être utilisée avec l'attribut keyTimes, comme dans l'exemple suivant :

<animateColor attributeName="color" dur="10s" calcMode="discrete"
     values="green; yellow; red" keyTimes="0.0; 0.8;" />

Cet exemple montre également comment les valeurs keyTimes peuvent interagir avec une durée indéfinie. La valeur de l'attribut "color" sera mise à "green" pendant 5 secondes, et ensuite restera à "yellow" pendant 5 secondes, et ensuite restera à "red" pour le reste du document, jusqu'à la durée (non-spécifiée) définie par défaut à "indefinite".

L'exemple suivant illustre une utilisation de l'attribut keyTimes :

<animate attributeName="x" dur="10s" values="0; 50; 100"
     keyTimes="0; .8; 1" calcMode="linear"/>

Les valeurs de keyTimes font avoir une valeur de "0" à l'attribut "x" au commencement de l'animation, "50" après 8 secondes (à 80% de la durée) et "100" à la fin de l'animation. La valeur changera plus lentement dans la première moitié de l'animation et plus rapidement dans la seconde moitié.

L'interpolation avec keySplines

Pour certains attributs, le rythme du changement peut ne pas être facilement discernable par les spectateurs. Cependant pour les animations comme les mouvements, la possibilité de représenter la vitesse du mouvement graduellement, et non de façon abrupte, peut être importante. L'attribut keySplines permet ce contrôle.

En prolongeant l'exemple ci-dessus pour utiliser l'attribut keySplines :

<animate attributeName="x" dur="10s" values="0; 50; 100"
     keyTimes="0; .8; 1" calcMode="spline" 
     keySplines=".5 0 .5 1; 0 0 1 1" />

Les valeurs de keyTimes font à nouveau avoir une valeur de "0" à l'attribut "x" au commencement de l'animation, "50" après 8 secondes et "100" à la fin de l'animation. Cependant, les valeurs de keySplines définissent une courbe rythmant l'interpolation entre les valeurs. Dans l'exemple ci-dessus, la spline cause un effet ease-in et ease-out entre 0 et 8 secondes (i.e., entre les valeurs de l'attribut keyTimes 0 et 0.8, et les valeurs de l'attribut values "0" et "50"), mais une interpolation linéaire stricte entre 8 secondes et la fin (i.e., entre les valeurs de keyTimes 0.8 et 1, et les valeurs de values "50" et "100"). La Figure 7 montre les courbes que ces valeurs de keySplines définissent.

Figure 7 - Illustration de l'effet de keySplines

Example keySplines01 - keySplines of 0 0 1 1 (the default)
keySplines="0 0 1 1"
(par défaut)
Example keySplines02 - keySplines of .5 0 .5 1
keySplines=".5 0 .5 1"
 
Example keySplines03 - keySplines of 0 .75 .25 1
keySplines="0 .75 .25 1"
Example keySplines04 - keySplines of 1 0 .25 .25
keySplines="1 0 .25 .25"

Chaque diagramme de la Figure 7 illustre l'effet des configurations de keySplines pour un intervalle simple (i.e., entre les couples associés de valeurs des listes de keyTimes et values). L'axe horizontal peut être considéré comme valeur d'entrée pour la progression de l'unité de l'interpolation dans l'intervalle - i.e., le pas selon lequel l'interpolation avance le long de l'intervalle donné. L'axe vertical est la valeur résultante de la progression de l'unité, produite par la fonction keySplines. Une autre façon de décrire ceci est que l'axe horizontal est l'unité de temps en entrée pour l'intervalle et que l'axe vertical est l'unité de temps en sortie. Voir également la section « La temporisation et les temps des horloges réelles ».

Pour illustrer les calculs, considérez l'exemple simple :

<animate dur="4s" values="10; 20" keyTimes="0; 1"
     calcMode="spline" keySplines={as in table} />

En utilisant les valeurs de keySplines pour chacun des quatre cas ci-dessus, les valeurs interpolées approximatives selon l'avancement de l'animation sont :

Valeurs de keySplines Valeur initiale Après 1s Après 2s Après 3s Valeur finale
0 0 1 1 10.0 12.5 15.0 17.5 20.0
.5 0 .5 1 10.0 11.0 15.0 19.0 20.0
0 .75 .25 1 10.0 18.0 19.3 19.8 20.0
1 0 .25 .25 10.0 10.1 10.6 16.9 20.0

Pour une définition formelle du calcul des splines de Bézier, voir [COMP-GRAPHICS], pages 488-491.

Les attributs keyTimes et keySplines peuvent également être employés avec les formes from/to/by pour spécifier des valeurs, comme dans l'exemple suivant :

<animate attributeName="foo" from="10" to="20"
     dur="10s" keyTimes="0.0; 0.7"
     calcMode="spline" keySplines=".5 0 .5 1" />

La valeur changera de 10 à 20, en utilisant une courbe "ease-in/ease-out" spécifiée par les valeurs de keySplines. Les valeurs de keyTimes font atteindre la valeur 20 en 7 secondes et la font garder pour le reste des 10 secondes de la durée simple.

L'exemple suivant décrit un usage quelque peu inhabituel, une animation from-to avec une animation discrète. L'attribut stroke-linecap des éléments SVG prend comme valeur une chaîne, ce qui implique ainsi d'avoir calcMode à discrete. L'animation fixera l'attribut stroke-linecap à round pendant 5 secondes (la moitié de la durée simple) et ensuite fixera stroke-linecap à square pendant 5 secondes.

<rect stroke-linecap="butt"...>
   <animate attributeName="stroke-linecap"
      from="round" to="square" dur="10s"/>
</rect>

3.7.2 Les éléments du module SplineAnimation de SMIL 2.0

Le module SplineAnimation prolonge les éléments de BasicAnimation animate, animateMotion et animateColor, en ajoutant les attributs keyTimes et keySplines, et la valeur spline à l'attribut caclMode.

3.7.3 L'élément spline animate

Le module SplineAnimation prolonge l'élément animate défini par le module BasicAnimation, en ajoutant les attributs et valeurs suivants.

Attributs de l'élément
 
Tous les attributs et éléments associés de l'élément animate dans BasicAnimation.
Voir « L'élément animate ».
keyTimes,
keySplines et
calcMode
 
 
Prolongent la spécification de la fonction et de l'effet d'animation. Voir « L'élément animate » et « Le mode de calcul de la fonction d'animation spline ».

Des exemples sont donnés plus haut, ainsi que les définitions normatives de la sémantique de tous les attributs reconnus par animate.

3.7.4 L'élément spline animateMotion

Le module SplineAnimation prolonge l'élément animateMotion défini par le module BasicAnimation, en ajoutant les attributs et valeurs suivants.

Attributs de l'élément
 
Tous les attributs et éléments associés de l'élément animateMotion dans BasicAnimation.
Voir « L'élément animateMotion ».
keyTimes,
keySplines et
calcMode
 
 
Prolongent la spécification de la fonction et de l'effet d'animation. Voir « L'élément animateMotion » et « Le mode de calcul de la fonction d'animation spline ».
path
Spécifie la courbe qui décrit la valeur de l'attribut en fonction du temps. La syntaxe gérée est un sous-ensemble de la syntaxe de tracé de SVG. La gestion inclut les commandes pour décrire des lignes ("MmLlHhVvZz") et des courbes de Bézier ("Cc"). Pour les détails, se référer à la spécification de tracé dans SVG [SVG].
Notez que SVG fournit deux formes de commandes de tracé : « absolue » et « relative ». Ces termes peuvent sembler liés à la définition d'une animation additive et/ou à l'attribut from, mais ils sont orthogonaux. Les termes « absolu » et « relatif » s'appliquent seulement à la définition du tracé lui-même, et pas à l'opération de l'animation. Les commandes « relatives » définissent un point de tracé relatif au précédent point spécifié. Les termes « absolu » et « relatif » n'ont aucun rapport avec les définitions d'une animation « additive » ni avec une quelconque spécification d'un attribut origin.
  • Pour les commandes « absolues » ("MLHVZC"), le langage hôte doit spécifier le système de coordonnées des valeurs du tracé ;
  • Si les commandes « relatives » ("mlhvzc") sont employées, elles définissent simplement le point comme un décalage par rapport au point précédent sur le tracé. Ceci n'affecte pas la définition de "additive" ou de l'attribut origin de l'élément animateMotion.

Un segment de données de tracé doit débuter avec l'une des commandes "moveto".

Commandes Move To - "M <x> <y>" ou "m <dx> <dy>"
Commencent un nouveau sous-tracé aux coordonnées (x,y) données. Si un moveto est suivi par plusieurs couples de coordonnées, les couples ultérieurs sont traités comme des commandes lineto implicites.
Commandes Line To - "L <x> <y>" ou "l <dx> <dy>"
Dessinent une ligne du point courant aux coordonnées (x,y) données qui deviennent le nouveau point courant. Un certain nombre de couples de coordonnées peut être spécifié pour dessiner une polyligne.
Commandes Line To horizontales - "H <x>" ou "h <dx>"
Dessinent une ligne horizontale du point courant (cpx, cpy) à (x, cpy). Plusieurs valeurs x peuvent être données.
Commandes Line To verticales - "V <y>" ou "v <dy>"
Dessinent une ligne verticale du point courant (cpx, cpy) à (cpx, y). Plusieurs valeurs y peuvent être données.
Commandes Closepath - "Z" ou "z"
Le "closepath" entraîne le dessin d'une ligne droite automatiquement du point courant au point initial du sous-tracé courant.
Commandes de Bézier cubique Curve To - 
  "C <x1> <y1> <x2> <y2> <x> <y>" ou 
  "c <dx1> <dy1> <dx2> <dy2> <dx> <dy>"
Dessinent une courbe de Bézier cubique du point courant à (x,y) en utilisant (x1,y1) comme point de contrôle au début de la courbe et (x2,y2) comme point de contrôle à la fin de la courbe. Plusieurs jeux de coordonnées peuvent être spécifiés pour dessiner un polybezier.

Pour tous les paramétrages de calcMode, la définition de la fonction d'animation simple f(t) utilise le nombre de valeurs de l'attribut values pour déterminer comment la durée simple d est divisée en segments. Quand un attribut path est employé, le nombre de valeurs est défini comme étant le nombre de points définis par le tracé, à moins qu'il n'y ait des commandes "move to" dans le tracé. Une commande "move to" ne définit pas un « segment » supplémentaire pour la temporisation ou l'interpolation. Une commande "move to" ne compte pas comme un point supplémentaire en divisant la durée. Quand l'attribut path est combiné avec une propriété calcMode avec une valeur de paced, toutes les commandes "move to" sont considérées avoir une durée de 0 (i.e., elles surviennent toujours instantanément) et ne devraient pas être prises en compte pour calculer l'allure.

Si l'attribut path est spécifié, toutes les valeurs des attributs from/to/by ou values seront ignorées.

Des exemples sont données plus haut, ainsi que les définitions normatives de la sémantique de tous les attributs reconnus par animate.

Pour compléter le contrôle de vitesse, calcMode peut être mis à la valeur spline et l'auteur peut spécifier un contrôle de vitesse spline avec les attributskeyTimes et keySplines.

3.7.5 L'élément spline animateColor

Le module SplineAnimation prolonge l'élément animateColor défini par le module BasicAnimation, en ajoutant les attributs et valeurs suivants.

Attributs de l'élément
 
Tous les attributs et éléments associés de l'élément animateColor dans BasicAnimation.
Voir « L'élément animateColor ».
keyTimes,
keySplines et
calcMode
 
 
Prolongent la spécification de la fonction et de l'effet d'animation. Voir « L'élément animateColor » et « Le mode de calcul de la fonction d'animation spline ».

3.8 Le détail du module SplineAnimation de SMIL 2.0

3.8.1 Les conditions requises pour l'intégration de SplineAnimation

Pour spécifier l'intégration du module SplineAnimation de SMIL 2.0 dans un langage hôte, le concepteur de langage doit intégrer BasicAnimation de SMIL 2.0 dans le langage, en satisfaisant toutes les exigences listées dans « Les conditions requises pour l'intégration de BasicAnimation ».

En plus d'intégrer BasicAnimation, les exigences listées dans « Les conditions requises communes pour l'intégration d'une animation » doivent être satisfaites pour le module SplineAnimation.

3.8.2 La définition du type de document (DTD) pour le module SplineAnimation

Voir le DTD complet des modules d'animation de SMIL.

3.9 Les conditions requises pour l'intégration d'une animation

Cette section présente les problèmes liés à l'intégration avec le langage hôte qui sont les mêmes pour les modules BasicAnimation et SplineAnimation.

3.9.1 Les conditions requises pour l'intégration

Le profil de langage hôte doit intégrer le module BasicInlineTiming de SMIL 2.0 dans le langage hôte, en satisfaisant toutes les exigences de ce module. De plus, tous les modules parmi ceux de temporisation et de synchronisation et ceux de manipulation des temps de SMIL 2.0, qui sont intégrés dans le langage hôte, doivent être disponibles pour les éléments de BasicAnimation.

En particulier, l'attribut fill est géré par les éléments d'animation seulement si le langage hôte intègre le module BasicTimeContainers de SMIL 2.0 en plus du module BasicInlineTiming.

Le profil du langage hôte peut ajouter des attributs supplémentaires aux éléments d'animation. Les attributs ajoutés à un quelconque élément d'animation doivent être ajoutés à tous les éléments d'animation. En particulier, ce module ne définit pas d'attribut ID XML. Il est attendu du profil de langage hôte qu'il ajoute un attribut ID XML aux éléments d'animation.

L'extension de l'animation

Les concepteurs de langage intégrant l'animation de SMIL sont encouragés à définir de nouveaux éléments d'animation où de telles additions seront à la convenance des auteurs. Les nouveaux éléments doivent être basés sur l'animation de SMIL et la temporisation et la synchronisation de SMIL, et doivent s'inscrire dans le cadre établi par la temporisation et la synchronisation de SMIL et par l'animation de SMIL.

Les concepteurs de langage sont également encouragés à définir la gestion des animations additives et cumulatives pour les types de données non-numériques où l'addition peut raisonnablement être définie.

Les contraintes sur la manipulation des éléments d'animation

Les concepteurs de langage intégrant l'animation de SMIL sont encouragés à interdire la manipulation des attributs des éléments d'animation après que le document a débuté. Ceci inclut les attributs spécifiant les cibles et les valeurs, aussi bien que les attributs temporels. En particulier, les attributs id (de type ID) sur tous les éléments d'animation ne doivent pas être modifiables (i.e., devraient être en lecture seule). Exiger que les exécutions d'animation recherchent les changements des valeurs id introduit une considérable complexité, ce qui est au mieux une fonctionnalité discutable.

Il est recommandé que les spécifications des langages interdisent la manipulation des attributs des éléments d'animation à travers les interfaces DOM après que le document a débuté. Il est également recommandé que les spécifications des langages interdisent d'utiliser des éléments d'animation pour cibler d'autres éléments d'animation.

Notez en particulier que si l'attribut attributeName peut être modifié (par animation ou par script), des problèmes peuvent surgir si l'attribut cible a un nom qualifié d'espace de nommage. Les spécifications du DOM courant n'incluent pas de mécanismes pour gérer cette relation.

Changer dynamiquement les valeurs de l'attribut des éléments d'animation introduit des complications sémantiques au modèle qui ne sont pas encore suffisamment résolues. Cette contrainte peut être levée dans une future version d'Animation de SMIL.

La gestion des erreurs de syntaxe

Les mécanismes spécifiques de gestion des erreurs pour chaque attribut sont décrits dans les définitions de syntaxe individuelles. Certaines de ces spécifications décrivent le comportement d'une animation avec des erreurs de syntaxe comme « n'ayant pas d'effet ». Ceci signifie que l'animation continuera de se comporter normalement, avec le respect de la temporisation, mais ne manipulera aucune valeur de présentation, et donc n'aura pas d'impact visible sur la présentation.

En particulier, ceci signifie que si d'autres éléments d'animation sont définis pour débuter ou se terminer relativement à une animation « n'ayant pas d'effet », les autres éléments d'animation débuteront et se termineront comme s'il n'y avait pas d'erreur de syntaxe. L'environnement de présentation peut indiquer une erreur, sans nécessiter l'arrêt de la présentation ou de l'animation du document.

Certains langages hôtes et/ou exécutions peuvent choisir d'imposer une gestion d'erreur plus stricte (voir aussi « La sémantique de la gestion d'erreur » pour une discussion des problèmes du langage hôte avec la gestion d'erreur). L'environnement d'édition peut aussi choisir d'être plus intrusif quand des erreurs sont détectées.

La sémantique de la gestion d'erreur

Le concepteur du langage hôte peut imposer des contraintes plus strictes sur la sémantique de la gestion d'erreur. C'est-à-dire, dans le cas des erreurs de syntaxe, le langage hôte peut spécifier des mécanismes supplémentaires ou des mécanismes plus stricts utilisés pour indiquer une erreur. Un exemple pourrait être d'interrompre tout traitement du document, ou d'arrêter toute animation.

Les concepteurs de langage hôte peuvent ne pas relâcher les spécifications de la gestion d'erreur ou la réponse de la gestion d'erreur (comme décrit dans « La gestion des erreurs de syntaxe »). Par exemple, les concepteurs de langage hôte peuvent ne pas définir la sémantique de la récupération des erreurs pour les valeurs manquantes ou erronées des attributs values ou keyTimes.


précédent   suivant   sommaire