Lisez-moi S.V.P. 

W3C

SMIL Animation

Recommandation du W3C du 4 septembre 2001

Cette version :
http://www.w3.org/TR/2001/REC-smil-animation-20010904/
Dernière version :
http://www.w3.org/TR/smil-animation
Version précédente :
http://www.w3.org/TR/2001/PR-smil-animation-20010719
Rédacteurs :
Patrick Schmitz (pschmitz@microsoft.com), Microsoft
Aaron Cohen (aaron.m.cohen@intel.com), Intel

Résumé

Cette recommandation du W3C est une spécification de fonctionnalités d'animation pour les documents XML. La spécification décrit un cadre d'animation ainsi qu'un jeu d'éléments d'animation XML de base approprié pour une intégration aux documents XML. Elle est fondée sur le modèle de temporisation de SMIL 1.0, avec quelques extensions, et constitue un véritable sous-ensemble de SMIL 2.0. C'est un tremplin intermédiaire en termes de complexité de mise en œuvre pour les applications voulant des animations compatibles avec SMIL mais n'ayant pas besoin ou ne voulant pas de conteneurs temporels.

Statut de ce document

Cette section décrit le statut de ce document au moment de sa publication. D'autres documents peuvent venir le remplacer. Le dernier état de cette série de documents est conservé par le W3C.

Ce document a été revu par les membres du W3C et les tiers intéressés, et il a été approuvé par le Directeur comme recommandation du W3C. C'est un document stable qui peut être utilisé comme matériel de référence ou cité comme référence normative par un autre document. Le rôle du W3C en produisant la recommandation consiste à attirer l'attention sur la spécification et à promouvoir son large déploiement. Cela participe à améliorer la fonctionnalité et l'interopérabilité du Web.

La spécification SMIL Animation, produite dans le cadre de l'activité Synchronized MultiMedia du W3C, a été rédigée par le groupe de travail SYMM (accès réservé aux membres) du domaine Interaction du W3C, en coopération avec le groupe de travail SVG (accès réservé aux membres) du domaine Documents Formats du W3C. Les objectifs du groupe de travail SYMM sont exposés dans la charte du groupe de travail SYMM (accès réservé aux membres), révisée en juillet 2000 à partir de la version originale de la charte.

Le groupe de travail SYMM (accès réservé aux membres) estime que toutes les fonctionnalités de la spécification SMIL 2.0 ont été mises en œuvre au moins deux fois et sont interopérables. La charte du groupe de travail SYMM (accès réservé aux membres) décrit cela comme un développement indépendant des mises en œuvre par des organisations différentes et le passage avec succès de chaque test de la suite de tests SMIL 2.0 par au moins deux mises en œuvre. Les résultats de mise en œuvre sont publiés et servent uniquement à prouver que la mise en œuvre de SMIL 2.0 est possible. Il s'agit seulement d'un instantanné du comportement réel des mises en œuvre à un moment dans le temps, puisque ces mises en œuvre ne sont peut-être pas immédiatement disponibles pour le public. Les données d'interopérabilité ne sont pas destinées à évaluer ou à noter les performances d'une mise en œuvre individuelle.

Des divulgations de brevets et des engagements de licence sont attachés à la spécification SMIL 2.0 (et donc aussi à la spécification SMIL Animation), et on peut les consulter sur la page des déclarations de brevets du SYMM conformément à la politique du W3C.

Veuillez signaler les erreurs dans ce document à www-smil@w3.org. La liste des erreurs connues dans cette spécification est disponible à http://www.w3.org/2001/09/REC-smil-animation-20010904-errata.

On peut trouver la liste des recommandations et des autres documents courants du W3C à http://www.w3.org/TR.


Table des matières abrégée


Table des matières détaillée


1. Introduction

Ce document décrit un cadre pour incorporer une animation sur une ligne du temps et un mécanisme pour composer les effets de plusieurs animations. On décrit également un jeu d'éléments d'animation de base applicable à n'importe quel langage basé sur [XML]. On appelle le langage auquel ce module est intégré le langage hôte. On appelle le document qui contient les éléments d'animation le document hôte.

Une animation est par nature fonction du temps. La spécification SMIL Animation est définie dans les termes du modèle de temporisation SMIL. Les capacités d'animation sont décrites par des éléments nouveaux, avec les attributs et la sémantique associés, tout comme les attributs de temporisation SMIL. L'animation est modélisée comme une fonction changeant la valeur présentée d'un attribut particulier dans le temps.

Le modèle de temporisation est fondé sur SMIL 1.0 [SMIL1.0], avec quelques changements et extensions pour gérer des fonctionnalités de temporisation supplémentaires. La spécification SMIL Animation utilise un modèle de temporisation plat simplifié, sans conteneur de temps (tels que les éléments par ou seq). Cette version de SMIL Animation ne peut pas être utilisée avec des documents soumis par ailleurs à une temporisation. Cf. également la section Les définitions et contraintes obligatoires de la temporisation des éléments.

Quoique ce document définisse un ensemble de base de capacités d'animation, on suppose que les langages hôtes en tireront peut-être parti pour définir des éléments d'animation supplémentaires ou plus spécialisés. Pour assurer la cohérence du modèle auprès des auteurs de documents et des développeurs de moteurs d'exécution, nous introduisons un cadre pour intégrer l'animation au modèle de temporisation de SMIL. L'animation manipule seulement les attributs et propriétés des éléments cibles, et elle n'a donc pas besoin d'une connaissance spécifique de la sémantique de l'élément cible.

Les exemples dans ce document qui incluent une syntaxe de langage hôte utilisent les langages SMIL, SVG, XHTML et CSS. Ils sont fournis comme indication d'intégrations possibles à des langages hôtes variés.

2. Aperçu et terminologie

2.1. Les bases de l'animation

On définit l'animation comme la manipulation en fonction du temps d'un élément cible (ou plus précisément d'un certain attribut de l'élément cible : l'attribut cible). L'animation définit une application du temps aux valeurs de l'attribut cible. Cette application tient compte de tous les aspects de la temporisation, ainsi que de la sémantique propre à l'animation.

Les animations définissent un début et une durée simple qui peut être répétée. Chaque animation définit une fonction d'animation qui produit une valeur de l'attribut cible à chaque instant dans la durée simple. L'auteur peut définir pendant combien de temps et combien de fois la fonction d'animation devrait se répéter. La durée simple combinée à un comportement de répétition définit la durée active.

L'attribut cible est le nom d'une caractéristique d'un élément cible comme défini dans le document de langage hôte. Ça peut être (par exemple) un attribut XML contenu dans l'élément ou bien une propriété CSS appliquée à l'élément. Par défaut, l'élément cible d'une animation sera le parent de l'élément d'animation (l'élément d'animation est typiquement un sous-élément de l'élément cible). Toutefois, la cible peut être n'importe quel élément dans le document, identifié soit par une référence ID, soit via une référence de localisateur XLink [XLink].

Comme exemple simple, voici la définition d'une animation de forme rectangulaire SVG. Le rectange variera d'une forme allongée mince à une forme aplatie 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 débute par une largeur de 10 pixels augmentant jusqu'à 100 pixels pendant 10 secondes. Au cours de ces mêmes dix secondes, la hauteur du rectangle varie de 100 pixels à 10 pixels.

Lorsque l'animation se déroule, elle ne devrait pas changer réellement les valeurs d'attributs dans le modèle objet du document (DOM) [DOM2Core]. Le moteur d'animation devrait conserver une valeur de présentation pour chaque attribut animé, distincte du DOM ou du modèle objet CSS (CSS OM). Si la mise en œuvre ne gère pas de modèle objet, elle devrait conserver la valeur originale telle que définie par le document ainsi que la valeur de présentation. La valeur de présentation se reflète dans la forme affichée du document. Les animations manipulent donc la valeur de présentation et ne devraient pas affecter la valeur de base exposée par le DOM ou le CSS OM. Cela est précisé dans la section Le modèle d'animation en sandwich.

Au besoin, la mise en œuvre évalue la fonction d'animation au cours du temps et les valeurs obtenues 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 à toute cadence d'images appropriée pour le système de rendu. La représentation syntaxique de la fonction d'animation est indépendante de ce modèle et on peut la décrire de plusieurs façons. Les éléments d'animation dans cette spécification gèrent la syntaxe d'un jeu de valeurs discrètes ou interpolées, une syntaxe de tracé pour un mouvement basé sur les tracés SVG, une temporisation par images clés, une interpolation à vitesse régulière et des variantes de ces fonctionnalités. Les fonctions d'animation auraient pu être définies comme entièrement ou partiellement algorithmiques (par exemple, une fonction à valeur aléatoire ou une animation de mouvement suivant la position de la souris). Dans tous les cas, l'animation expose cela comme une fonction du temps.

La valeur de présentation reflète l'effet de l'animation sur la valeur de base. L'effet est le changement de la valeur de l'attribut cible à tout instant donné. Lorsqu'une animation se termine, l'effet de l'animation cesse de s'appliquer et la valeur de présentation revient par défaut à la valeur de base. L'effet de l'animation peut aussi être prolongé afin de figer la dernière valeur pour le restant de la durée du document.

On peut définir les animations pour remplacer ou bien pour ajouter à la valeur de base de l'attribut. Dans ce contexte, la valeur de base peut être la valeur du DOM ou le résultat d'autres animations visant aussi le même attribut. Ce concept plus général de valeur de base est appelé valeur sous-jacente. Les animations qui ajoutent à la valeur sous-jacente sont dites additives. Les animations qui remplacent la valeur sous-jacente sont dites non additives.

2.2. Les valeurs des fonctions d'animation

Beaucoup d'animations définissent la fonction d'animation f(t) comme une succession de valeurs à appliquer dans le temps. Pour certains types d'attributs (par exemple, les nombres), on peut également décrire une fonction d'interpolation entre des valeurs.

Comme forme simple de description de valeurs, les éléments d'animation peuvent indiquer une valeur pour l'attribut from et une valeur pour l'attribut to. Si l'attribut admet une valeur propice à l'interpolation (par exemple, un nombre), la fonction d'animation peut interpoler les valeurs dans l'intervalle défini par les attributs from et to au cours de la durée simple. Une variante utilise la valeur de l'attribut by à la place de celle de l'attribut to pour indiquer un changement additif sur l'attribut.

Les formes plus complexes définissent une liste de valeurs ou même la description d'un tracé de mouvement. Les auteurs peuvent également contrôler la temporisation des valeurs pour décrire des animations à images clés, et des fonctions plus complexes encore.

2.3. Les symboles utilisés dans les descriptions sémantiques

f(t)
La fonction d'animation simple associant les temps dans la durée simple aux valeurs de l'attribut cible (0 <= t <= durée simple). Remarquez, tandis que F(t) définit l'application de l'animation entière, que f(t) suit un modèle simplifié qui manipule juste la durée simple.
F(t)
L'effet d'une animation pour n'importe quel point de l'animation. Elle fait correspondre un temps non négatif à une valeur de l'attribut cible. Un temps de valeur "0" correspond au temps où l'animation débute. Remarquez que F(t) combine la fonction d'animation f(t) avec tous les autres aspects de l'animation et des contrôles de temporisation.

3. Le modèle d'animation

Cette section décrit la syntaxe et la sémantique des attributs pour décrire les animations. Les éléments spécifiques ne sont pas décrits ici, mais plutôt les concepts et syntaxe communs qui composent le modèle d'animation. On décrit les problèmes des documents, ainsi que les méthodes pour viser un élément pour une animation. On définit ensuite le modèle d'animation, en allant des concepts les plus simples aux les plus complexes : d'abord la durée simple et la fonction d'animation f(t), puis le comportement global de F(t). Enfin, on présente le modèle pour combiner les animations et on décrit les informations supplémentaires concernant la temporisation de l'animation.

Le modèle temporel dépend de plusieurs définitions pour le document hôte : le document hôte est présenté pendant un certain intervalle de temps. On appelle le début de l'intervalle où le document est présenté le début du document. La fin de l'intervalle où le document est présenté est appelée fin du document. La différence entre ce début et cette fin est appelée durée du document. Les définitions formelles de la présentation, du début et de la fin du document sont laissées au concepteur du langage hôte (cf. également la section Les définitions obligatoires du langage hôte).

3.1. La définition de la cible d'animation

La cible d'animation est définie comme étant un attribut spécifique d'un élément particulier. Les méthodes pour définir l'attribut cible et l'élément cible sont précisées dans cette section.

L'attribut cible

L'attribut cible à animer est indiqué par l'attribut attributeName. La valeur de cet attribut est une chaîne indiquant le nom de l'attribut cible comme défini dans le langage hôte.

Les attributs d'un élément animable sont souvent définis par des langages différents et/ou dans des espaces de nommage différents. Par exemple, dans beaucoup d'applications XML, la position d'un élément (qui est un attribut cible typique) est définie par une propriété CSS au lieu d'un attribut XML. Parfois, le même nom d'attribut est associé aux attributs et propriétés de plusieurs langages ou espaces de nommage. Pour permettre à l'auteur de lever l'ambiguïté de l'association de nom, un attribut supplémentaire attributeType pour indiquer l'interprétation attendue est fourni.

L'attribut attributeType est optionnel. Par défaut, le moteur d'animation résoudra les noms selon la règle suivante : s'il y a un conflit de noms et que l'attribut attributeType n'est pas défini, la liste de propriétés CSS gérées par le langage hôte est associée en premier (si CSS est géré dans le langage hôte) ; si aucune association CSS n'est faite (ou si CSS ne s'applique pas), l'espace de nommage par défaut de l'élément cible sera associé.

Si l'attribut cible est défini dans un espace de nommage XML différent de celui par défaut de l'élément cible, alors l'auteur doit définir l'espace de nommage de l'attribut cible en utilisant le préfixe d'espace de nommage associé défini dans la portée de l'élément d'animation. Le préfixe est ajouté devant la valeur de l'attribut attributeName.

Cf. [XML-NS] pour des précisions sur les espaces de nommage XML.

attributeName = <attributeName>
Indique le nom de l'attribut cible. On peut utiliser un préfixe xmlns pour indiquer l'espace de nommage XML de l'attribut. Le préfixe sera interprété dans la portée de l'élément d'animation.
attributeType = "CSS | XML | auto"
Indique l'espace de nommage où sont définis l'attribut cible et les valeurs associées. La valeur de l'attribut est l'une des suivantes (les valeurs sont sensibles à la casse) :
"CSS"
Elle indique que la valeur de l'attribut attributeName est le nom d'une propriété CSS comme définie pour le document hôte. Cette valeur d'argument n'est significative que dans les environnements de langages hôtes gérant CSS.
"XML"
Elle indique que la valeur de l'attribut attributeName est le nom d'un attribut XML défini dans l'espace de nommage XML par défaut de l'élément cible. Remarquez que si la valeur de l'attribut attributeName a un préfixe xmlns, alors la mise en œuvre doit utiliser l'espace de nommage associé comme défini dans la portée de l'élément d'animation.
"auto"
La mise en œuvre devrait associer la valeur de l'attribut attributeName à un attribut de l'élément cible. La mise en œuvre doit d'abord explorer la liste des propriétés CSS à la recherche d'un nom de propriété correspondant et, si elle n'en trouve pas, explorer ensuite l'espace de nommage XML par défaut de l'élément.
C'est la valeur par défaut.

L'élément cible

Un élément d'animation peut définir l'élément cible d'animation explicitement ou bien implicitement. La définition explicite utilise un attribut pour indiquer l'élément cible. Sa syntaxe est décrite ci-dessous.

Si aucune cible explicite n'est indiquée, alors l'élément cible implicite est l'élément parent de l'élément d'animation dans l'arbre du document. La situation courante attendue est celle où l'élément d'animation sera déclaré comme enfant de l'élément à animer. Auquel cas, il est inutile d'indiquer une cible explicite.

Si la référence d'un élément cible explicite ne peut pas être résolue (par exemple, si l'élément est introuvable), l'animation est sans effet. Et de même si l'élément cible (implicite ou explicite) ne gère pas l'attribut cible indiqué. Cf. également la section Le traitement des erreurs de syntaxe.

Les deux attributs suivants peuvent servir à identifier explicitement l'élément cible :

targetElement = "<IDREF>"
Cet attribut indique l'élément cible à animer. La valeur d'attribut doit être celle de l'identificateur d'attribut XML d'un élément dans le document hôte. Pour une définition formelle du type IDREF, se reporter à la spécification XML 1.0 [XML].
href = uri-reference
Cet attribut définit un localisateur XLink qui se rapporte à l'élément cible à animer.

Pour l'intégration d'éléments d'animation dans un langage hôte, le concepteur du langage devrait éviter d'inclure ces deux attributs en même temps. Si malgré tout le concepteur du langage hôte choisit d'inclure les deux attributs, les deux étant définis sur un élément d'animation donné, alors l'attribut XLink href a priorité sur l'attribut targetElement.

L'utilisation de l'attribut targetElement présente l'avantage d'une syntaxe de la valeur d'attribut plus simple, comparée à celle de l'attribut href. L'avantage d'utiliser l'attribut XLink href est qu'il pourra s'étendre vers un mécanisme de liaison complet dans les versions futures de SMIL Animation, et que les processeurs XLink génériques peuvent traiter l'élément d'animation. La forme XLink sert également pour les langages hôtes conçus pour utiliser XLink avec toutes ces références. Les deux exemples suivants illustrent ces deux approches.

Cet exemple utilise la syntaxe plus simple de l'attribut targetElement :

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

Cet exemple utilise la syntaxe plus flexible du localisateur XLink, avec une cible équivalente :

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

Si 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. On peut les définir dans une définition DTD, ou le langage hôte peut leur imposer dans la syntaxe du document de gérer les processeurs XLink génériques. Cf. le langage de liaison XML (XLink) [XLink] pour des précisions.

La spécification XLink impose les attributs XLink suivants. Les valeurs sont fixes, et elles peuvent donc être définies comme telles dans une définition DTD. Tous les autres attributs XLink sont optionnels et n'affectent pas la sémantique de SMIL Animation.

type = "simple"
Identifie le type de lien XLink utilisé. Pour relier l'élément cible, on utilise un lien simple et la valeur d'attribut doit donc être "simple".
actuate = "onLoad"
Indique que le lien vers l'élément cible est suivi automatiquement (c'est-à-dire sans intervention de l'utilisateur).
show = "embed"
Indique que la référence n'inclut pas d'autre contenu dans le fichier.

Les informations supplémentaires concernant la spécification de l'élément cible, en rapport avec le document hôte et le langage hôte, sont fournies dans la section Les définitions et contraintes obligatoires des cibles d'animation.

3.2. La définition de la fonction d'animation f(t)

Chaque fonction d'animation définit la valeur de l'attribut à un moment donné dans le temps. 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 de résultat défini pour les temps en dehors de l'intervalle allant de "0" à la valeur de la durée simple.

3.2.1. La temporisation de la fonction d'animation

La temporisation de base d'un élément est décrite avec les attributs begin et dur. Les auteurs peuvent indiquer le temps de début d'une animation de plusieurs façons, depuis les temps d'horloge simples jusqu'au temps où se produit un événement comme un clic de souris. La longueur de la durée simple est indiquée par l'attribut dur. La syntaxe de cet attribut est décrite plus loin. Les règles de syntaxe normatives de chaque variante de valeur d'attribut sont décrites dans la section Les grammaires des valeurs d'attributs de temporisation. Un résumé de la syntaxe est fourni ici pour aider le lecteur.

Cette section est normative

begin
Définit le moment où l'élément devient actif.
La valeur d'attribut est une liste de valeurs, séparées par des points-virgules.
begin-value-list : begin-value (";" begin-value-list )?
Une liste de valeurs de début, séparées par des points-virgules. L'interprétation d'une liste de temps de début est précisée dans la section L'évaluation des listes de temps de début et de fin.
begin-value : ( offset-value | syncbase-value | event-value | repeat-value | accessKey-value | media-marker-value | wallclock-sync-value | "indefinite" )
Décrit le début de l'élément.
offset-value : ( "+" | "-" )? Clock-value
Indique le temps de présentation où l'animation débute. Le début est défini relativement au début du document.
syncbase-value : ( Id-value "." ( "begin" | "end" ) ) ( ( "+" | "-" ) Clock-value )?
Décrit une base de synchronisation et un décalage à partir de cette base de synchronisation. Le début de l'élément est défini relativement au début ou à la fin active d'un autre élément.
event-value : ( Id-value "." )? ( event-ref ) ( ( "+" | "-" ) Clock-value )?
Décrit un événement et un décalage optionnel qui déterminent le début de l'élément. Le début de l'animation est défini relativement au temps où l'événement a lieu. Ces événements peuvent être tous ceux définis pour le langage hôte conformément à [DOM2Events]. Ils comprennent les événements d'interface utilisateur, les amorces d'événements transmises via un réseau, etc. Les informations concernant la temporisation interactive sont données dans la section suivante L'unification de la temporisation interactive et de la temporisation programmée.
repeat-value : ( Id-value "." )? "repeat(" integer ")" ( ( "+" | "-" ) Clock-value )?
Décrit un événement de répétition qualifié. Le début de l'événement est défini relativement au temps où l'événement de répétition a lieu avec la valeur d'itération indiquée.
accessKey-value : "accessKey(" character ")"
Décrit une touche d'accès qui détermine le début de l'élément. Le début de l'élément est défini relativement au temps où l'utilisateur saisit le caractère de la touche d'accès.
wallclock-sync-value : "wallclock(" wallclock-value ")"
Décrit le début de l'élément comme le temps d'une horloge du monde réel. La syntaxe du temps d'horloge se fonde sur celle définie dans [ISO8601].
"indefinite"
Le début de l'animation sera déterminé par un appel de la méthode beginElement() ou par un hyperlien visant l'élément d'animation.
Les méthodes DOM de SMIL Animation sont décrites dans la section Les interfaces prises en charge.
La temporisation par hyperliens est décrite dans la section Les hyperliens et la temporisation.
La sémantique de la valeur de l'attribut begin

Cette section est normative

Cette section est informative

La valeur de l'attribut begin peut définir une liste de temps. On peut l'utiliser pour indiquer plusieurs façons ou règles de débuter un élément, par exemple, si l'un de plusieurs événements se produit. La liste de temps peut aussi définir plusieurs temps de début, permettant la lecture à plusieurs reprises de l'élément (ce comportement peut être contrôlé, par exemple, pour utiliser seulement le début le plus ancien — cf. également la section La relance des animations).

En général, le temps le plus ancien dans la liste détermine le temps de début de l'élément. Il y a des contraintes supplémentaires pour l'évaluation de la liste des temps de début, qui sont précisées dans la section L'évaluation des listes de temps de début et de fin.

Bien qu'il soit légal d'inclure la valeur "indefinite" dans la liste de valeurs de l'attribut begin, remarquez qu'elle n'est réellement utile que comme valeur unique. En combinaison avec d'autres valeurs, elle n'agit pas sur la temporisation de début, puisqu'on peut appeler les méthodes de début du DOM en indiquant ou non la valeur "indefinite" pour l'attribut begin.

La manipulation des décalages négatifs de début

Cette section est informative

L'utilisation de décalages négatifs pour définir les temps de début définit simplement les relations de synchronisation de l'élément. Elle ne remplace en aucune façon les contraintes du conteneur de temps sur l'élément, et elle ne peut pas remplacer les contraintes de temps de présentation.

Cette section est normative

Le temps de début calculé définit la relation de synchronisation programmée de l'élément, même s'il n'est pas possible de débuter l'élément au temps calculé. Le modèle temporel utilise le temps de début calculé, et non le temps observé du début de l'élément.

Cette section est normative

L'élément débutera en fait au temps calculé d'après l'algorithme suivant :

Soit o la valeur de décalage d'une valeur de début donnée,
 d la durée simple associée,
 AD la durée active associée.
Soit rAt le temps de résolution du début.
Soit rTo le temps de base de synchronisation ou de base d'événement sans décalage
Soit rD valant rTo - rAt. Si rD < 0 alors rD est fixé à 0.
 
Si AD n'est pas définie, elle est supérieure à toute valeur de o ou ABS(o).
REM( x, y ) est défini par x - (y * floor( x/y )). 
Si y n'est pas défini, REM( x, y ) vaut simplement x.

Soit mb = REM( ABS(o), d ) - rD

Si ABS(o) >= AD alors l'élément ne débute pas.
Autrement si mb >= 0 alors le média débute à mb.
Sinon le média débute à mb + d.

Si l'élément se répète, la valeur d'itération de l'événement repeat prend la valeur calculée d'après le temps de début calculé ci-dessus, et non le nombre de répétitions observées.

Cette section est informative

Ainsi par exemple :

<animate begin="foo.click-8s" dur="3s" repeatCount="10" .../>

L'animation débute lorsque l'utilisateur clique sur l'élément "foo". Son temps de début calculé est en réalité 8 secondes plus tôt, et sa lecture débute donc à 2 secondes dans la durée simple de trois secondes de la troisième itération de répétition. La quatrième itération de l'élément débutera une seconde plus tard et l'événement repeat associé aura la valeur d'itération "3" (celle-ci commençant à zéro). L'élément se terminera 22 secondes après le clic. L'événement beginEvent est suscité lorsque l'élément débute, mais il a une valeur d'estampille correspondant au temps de début défini, qui est 8 secondes plus tôt. Tous les dépendants temporels sont activés relativement au temps de début calculé et non au temps de début observé.

Remarque : Si les auteurs de scripts souhaitent distinguer les itérations de répétion calculées des itérations de répétition observées, ils peuvent compter les événements repeat réels dans le gestionnaire d'événement associé.

dur
Définit la durée simple.
La valeur d'attribut peut avoir l'un des types suivants :
Clock-value
Définit la longueur de la durée simple dans le temps de la présentation.
La valeur doit être supérieure à "0".
"indefinite"
Définit la durée simple comme non définie.

Si aucun attribut begin n'est défini, la valeur par défaut est "0" (l'animation débute avec le document). S'il y a une erreur dans la syntaxe de la valeur d'argument de l'attribut begin, la valeur par défaut de begin sera utilisée.

Si l'animation n'a pas d'attribut dur, la durée simple n'est pas définie. Remarquez que l'interpolation ne fonctionnera pas si la durée simple n'est pas définie (quoique cela puisse toujours être utile pour les éléments set). Cf. également L'interpolation et les durées simples non définies.

S'il y a une erreur dans la syntaxe de la valeur d'argument de l'attribut dur, l'attribut sera ignoré (comme s'il n'avait pas été défini), et la durée simple ne sera donc pas définie.

Si la valeur de début est définie valoir "indefinite" ou définit une base d'événement, le temps du début n'est en réalité pas connu tant que l'élément n'est pas activé (par exemple, avec un hyperlien, l'appel d'une méthode du DOM ou l'événement appelé). Lorsqu'il n'est pas connu, on dit que le temps est non résolu. Le temps devient résolu au point où le début de l'élément est activé. Cela est décrit en détails dans la section L'unification de la temporisation interactive et de la temporisation programmée.

Exemples

Les exemples suivants définissent tous un début à minuit le 1er janvier 2000 UTC :

begin="wallclock(2000-01-01Z)"
begin="wallclock( 2000-01-01T00:00Z )"
begin="wallclock( 2000-01-01T00:00:00Z )"
begin="wallclock( 2000-01-01T00:00:00.0Z )"
begin="wallclock( 2000-01-01T00:00:00.0Z )"
begin="wallclock( 2000-01-01T00:00:00.0-00:00 )"

L'exemple suivant définit un début à 15 h 30 le 28 juillet 1990 dans le fuseau horaire des États-Unis sur le Pacifique :

begin="wallclock( 1990-07-28T15:30-08:00 )"

L'exemple suivant définit un début à 8 heures du matin à chaque fois que le document y est présenté :

begin="wallclock( 08:00 )"

3.2.2. Les valeurs de la fonction d'animation

Outre l'attribut cible et la temporisation, l'animation doit indiquer comment changer sa valeur au cours du temps. On peut décrire une animation soit comme une liste de valeurs de l'attribut values, soit dans une forme simplifiée avec les valeurs des attributs from, to et by.

from = "<valeur>"
Définit la valeur de départ de l'animation.
to = "<valeur>"
Définit la valeur d'arrivée de l'animation.
by = "<valeur>"
Définit une valeur de décalage relatif pour l'animation.
values = "<liste>"
Une liste d'une ou plusieurs valeurs, séparées par des points-virgules. Les attributs à valeurs vectorielles sont gérés au travers de la syntaxe vectorielle du domaine attributeType.

Si on utilise une liste de valeurs, l'animation appliquera les valeurs dans l'ordre au cours de l'animation (le rythme et l'interpolation entre ces valeurs sont décrites dans la section suivante). Si on définit une liste pour l'attribut values, les valeurs des attributs from, to et by sont toutes ignorées.

La syntaxe from/to/by plus simple comporte plusieurs variantes. Pour utiliser une variante, il faut définir l'un ou l'autre des attributs by ou to, la valeur de l'attribut from étant optionnelle. Il est illégal de définir les deux attributs by et to : si les deux sont définis, seul l'attribut to sera utilisé (l'attribut by sera ignoré). Les combinaisons d'attributs produisent les classes d'animation suivantes :

L'animation from-to
Indiquer une valeur from et une valeur to définit une animation simple équivalant à une liste values de deux valeurs. La fonction d'animation est définie pour commencer à la valeur from et finir à la valeur to.
L'animation from-by
Indiquer une valeur from et une valeur by définit une animation simple où la fonction d'animation est définie pour commencer à la valeur from et la changer au cours de la durée simple d'une valeur delta indiquée par l'attribut by. On ne peut l'utiliser qu'avec les attributs gérant l'addition (par exemple, la plupart des attributs numériques).
L'animation by
Indiquer uniquement une valeur by définit une animation simple où la fonction d'animation est définie pour décaler la valeur sous-jacente de l'attribut d'une valeur delta variant au cours de la durée simple, en commençant avec un delta de "0" et en finissant au delta indiqué par l'attribut by. On ne peut l'utiliser qu'avec les attributs gérant l'addition.
L'animation to
Elle décrit une animation où la fonction d'animation est définie pour commencer avec la valeur sous-jacente de l'attribut et finir avec la valeur indiquée par l'attribut to. Avec cette forme, l'auteur peut décrire une animation qui débutera à une valeur courante de l'attribut et se terminera à la valeur to souhaitée.

Les deux dernières formes animation by et animation to ont des contraintes sémantiques supplémentaires lorsqu'elles sont combinées avec d'autres animations. Cela est précisé ci-dessous dans la section Comment les attributs from, to et by affectent-ils le comportement additif.

Les valeurs d'animation définies dans l'élément d'animation doivent être des valeurs légales pour l'attribut indiqué. Cf. également la section Le détail des valeurs de la fonction d'animation.

Les caractères blancs de tête et de queue, ainsi que ceux avant et après les séparateurs points-virgules, sont ignorés.

Si toutes les valeurs (c'est-à-dire les valeurs arguments des attributs from, to, by ou values) sont illégales, alors l'animation sera sans effet (cf. également la section Le traitement des erreurs de syntaxe). Et de même, si aucun des attributs from, to, by ou values n'est défini.

L'interpolation et les durées simples non définies

Si la durée simple d'une animation n'est pas définie (par exemple, si aucune valeur n'est définie pour l'attribut dur), l'interpolation est en général dénuée de sens. Bien qu'il soit possible de définir une fonction d'animation non basée sur une durée simple définie (par exemple, un certain algorithme à nombres aléatoires), la plupart des animations définit la fonction d'interpolation par rapport à la durée simple. Si une fonction d'animation est définie par rapport à la durée simple et que cette durée simple n'est pas définie, alors la première valeur de la fonction d'animation (c'est-à-dire f(0)) devrait être utilisée (en fait comme une constante) pour la fonction d'animation.

Exemples

L'exemple suivant avec la syntaxe values anime la largeur d'une forme SVG sur une course de 10 secondes, en interpolant depuis une largeur de 40 jusqu'à 100, et retour à 40.

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

L'exemple d'animation from-to suivant anime la largeur d'une forme SVG sur une course de 10 secondes depuis une largeur de 50 jusqu'à 100.

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

L'exemple d'animation from-by suivant anime la largeur d'une forme SVG sur une course de 10 secondes depuis une largeur de 50 jusqu'à 75.

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

L'exemple d'animation by suivant anime la largeur d'une forme SVG sur une course de 10 secondes depuis la largeur originale de 40 jusqu'à 70.

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

L'exemple d'animation to suivant anime la largeur d'une forme SVG sur une course de 10 secondes depuis la largeur originale de 40 jusqu'à 100.

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

3.2.3. Les modes de calcul de la fonction d'animation

Par défaut, une interpolation linéaire simple est appliquée aux valeurs, espacée régulièrement sur la durée de l'animation. On peut utiliser des attributs supplémentaires pour un contrôle plus fin de l'interpolation et de la temporisation des valeurs. L'attribut calcMode définit la méthode d'application des valeurs à l'attribut en question. L'attribut keyTimes apporte un contrôle supplémentaire de la temporisation de la fonction d'animation, en associant un temps à chaque valeur de la liste de l'attribut values (ou aux points dans la description de tracé de l'attribut path d'un élément animateMotion, cf. la section L'élément animateMotion). Enfin, l'attribut keySplines permet de contrôler le rythme de l'interpolation entre les valeurs de la liste de l'attribut values.

calcMode = "discrete | linear | paced | spline"
Indique le mode d'interpolation de l'animation. Il peut prendre l'une des valeurs suivantes. Le mode par défaut est "linear", toutefois si l'attribut ne gère pas l'interpolation linéaire (par exemple, pour des chaînes), l'attribut calcMode est ignoré et une interpolation discrète est utilisée.
"discrete"
Cela signifie que la fonction d'animation sautera d'une valeur à la suivante sans interpolation.
"linear"
On utilise une interpolation linéaire simple entre les valeurs pour calculer la fonction d'animation.
C'est la valeur par défaut de l'attribut calcMode.
"paced"
Définit une interpolation qui produit une cadence de changement régulière tout au long de l'animation. Elle est seulement gérée pour les valeurs définissant un intervalle numérique linéaire, et pour lesquelles on peut calculer une certaine notion de distance entre les points (par exemple, la position, la largeur, la hauteur, etc.). Si la valeur "paced" est indiquée, les éventuels attributs keyTimes ou keySplines seront ignorés.
"spline"
Interpole depuis une valeur à la suivante dans la liste de l'attribut values conformément à une fonction de temps définie par une spline de Bézier cubique. Les points de la spline sont définis par l'attribut keyTimes et les points de contrôle de chaque intervalle sont définis par l'attribut keySplines.
keyTimes = "<liste>"
Une liste de valeurs de temps, séparées par des points-virgules, utilisée pour contrôler le rythme de l'animation. Chaque temps dans la liste correspond à une valeur dans la liste de l'attribut values et définit quand la fonction d'animation devrait utiliser cette valeur. Chaque valeur de temps dans la liste de l'attribut keyTimes est indiquée par une valeur en virgule flottante entre 0 et 1 (inclus) représentant un décalage proportionnel dans la durée simple de l'élément d'animation.

Si une liste d'attribut keyTimes est définie, alors il doit y avoir autant de valeurs exactement dans cette liste que dans la liste de l'attribut values.

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

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

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

S'il y a une erreur dans la définition de l'attribut keyTimes (valeurs erronées, trop ou pas assez de valeurs), l'animation sera sans effet.

Si la durée simple n'est pas définie, toute définition de l'attribut keyTimes sera ignorée.

keySplines = "<liste>"
Un ensemble de points de contrôle de Bézier, associé à la liste de l'attribut keyTimes, qui définit une fonction de Bézier cubique contrôlant la cadence des intervalles. La valeur de l'attribut est une liste de descriptions de points de contrôle, séparées par des points-virgules. Chaque description de point de contrôle forme un ensemble de quatre valeurs en virgule flottante x1 y1 x2 y2, qui décrit les points de contrôle de Bézier d'un seul segment de temps. Les valeurs de l'attribut keyTimes définissant le segment associé sont les points d'ancre de Bézier et les valeurs de l'attribut keySplines sont les points de contrôle. Il doit donc y avoir un ensemble de points de contrôle de moins que de valeurs keyTimes.

Les valeurs doivent toutes se trouver dans un intervalle de 0 à 1.

Cet attribut est ignoré à moins que l'attribut calcMode n'ait la valeur "spline".

S'il y a une erreur dans la définition de l'attribut keySplines (valeurs erronées, trop ou pas assez de valeurs), l'animation sera sans effet.

Si l'attribut calcMode vaut "discrete", "linear" ou "spline", et que l'attribut keyTimes n'est pas défini, alors les valeurs de l'attribut values sont supposées réparties équitablement tout au long de la durée de l'animation conformément au mode indiqué par calcMode :

La sémantique est la même si l'attribut keySplines est défini mais pas l'attribut keyTimes. Les temps associés aux valeurs de l'attribut keySplines sont déterminés comme décrit précédemment.

La syntaxe des jeux de points de contrôle dans les listes d'attributs keySplines est la suivante :

control-pt-set ::= ( fpval comma-wsp fpval comma-wsp fpval comma-wsp fpval )
fpval          ::= nombre en virgule flottante
comma-wsp      ::= S (spacechar|",") S

Les valeurs des points de contrôle sont séparées par au moins un caractère blanc ou une virgule. Les caractères blancs supplémentaires autour du séparateur sont permis. La syntaxe des nombres en virgule flottante doit être définie dans le langage hôte.

Pour les formes abrégées des animation from-to et animation from-by, il n'y a que deux valeurs. L'animation from-to de type "discrete" appliquera la valeur de l'attribut from pour la première moitié de la durée simple et la valeur de l'attribut to pour la seconde moitié. De façon similaire, l'animation from-by appliquera la valeur de l'attribut from pour la première moitié de la durée simple et, pour la seconde moitié, appliquera le résultat calculé d'après la valeur de l'attribut by. Pour la forme abrégée d'animation to, il n'y a qu'une seule valeur ; une animation to de type "discrete" appliquera simplement la valeur de l'attribut to pour la durée simple.

Si les valeurs d'arguments des attributs keyTimes ou keySplines ne sont pas légales (y compris pas assez ou trop de valeurs pour l'un ou l'autre attribut), l'animation sera sans effet (cf. également la section Le traitement des erreurs de syntaxe).

Dans les valeurs des attributs calcMode, keyTimes et keySplines, les caractères blancs de tête et de queue tout comme ceux avant et après les séparateurs points-virgules seront ignorés.

Les modes d'interpolation illustrés

Les trois illustrations 1a, 1b et 1c ci-dessous montrent comment la même animation de base va changer une valeur au cours du temps, en fonction des différents modes d'interpolation. Tous les exemples utilisent la temporisation par défaut (aucun attribut keyTimes ou keySplines n'est défini). Tous les exemples ont la trame suivante, sauf l'attribut calcMode qui prend juste des valeurs différentes :

<animate dur="30s" values="0; 1; 2; 4; 8; 15" calcMode="[comme indiqué]" />
Diagramme d'une interpolation discrète
Figure 1a : Animation discrète par défaut.

calcMode="discrete"

Il y a six segments de durée égale : un segment par valeur.

Diagramme d'une interpolation linéaire
Figure 1b : Animation linéaire par défaut.

calcMode="linear"

Il y a cinq segments de durée égale : n-1 segments pour n valeurs. L'interpolation spline est une décomposition de la forme linéaire, et elle est illustrée plus loin dans la figure 2.

Diagramme d'une interpolation régulée
Figure 1c : Animation régulée par défaut.

calcMode="paced"

Il y a cinq segments de durée variable : n-1 segments pour n valeurs, calculés pour produire un taux de variation constant dans la valeur.

Exemples

L'exemple suivant décrit une animation discrète simple :

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

La valeur de l'attribut foo se fixera sur chacune des quatre chaînes, pendant deux secondes chacune. Puisque les valeurs de chaînes ne peuvent pas être interpolées, seule est possible une animation de type "discrete", et tout attribut calcMode serait ignoré.

On peut aussi utiliser une animation "discrete" avec l'attribut keyTimes, comme dans l'exemple suivant :

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

Cet exemple montre aussi comment les valeurs d'attribut keyTimes peuvent interagir avec une durée indéfinie. La valeur de l'attribut color se fixera sur "green" pendant cinq secondes, puis sur "yellow" pendant cinq secondes et enfin sur "red" pour le restant du document, puisque la durée (non définie) vaut "indefinite" par défaut.

L'exemple suivant décrit une animation linéaire simple :

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

La valeur de l'attribut x changera de "0" à "10" au cours des cinq premières secondes, et de "10" à "100" au cours des cinq secondes suivantes. Remarquez que les valeurs dans l'attribut values sont espacées régulièrement dans le temps sans attribut keyTimes défini ; le résultat ici est une variation réelle de la valeur bien plus grande pendant la seconde moitié de l'animation. À comparer avec le même exemple utilisant cette fois une interpolation "paced" :

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

Pour produire un rythme de changement régulier de l'attribut x, le deuxième segment défini par la liste de l'attribut values reçoit la plus grande partie de la durée simple. La valeur de x changera de "0" à "10" au cours de la première seconde, puis de "10" à "100" au cours des neuf secondes suivantes. Quoiqu'on puisse aisément créer cet exemple comme une animation from-to sans interpolation régulière, beaucoup d'exemples (tels que les tracés de mouvement) sont plus difficiles à concevoir sans la valeur "paced" de l'attribut calcMode.

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

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

Les valeurs de l'attribut keyTimes font que l'attribut x a une valeur de "0" au début de l'animation, de "50" après huit secondes (à 80 % de la durée simple) et de "100" à la fin de l'animation. La valeur variera plus lentement dans la première moitié de l'animation et plus rapidement dans la seconde moitié.

En étendant cet exemple 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" />

L'attribut keyTimes fait que l'attribut x a toujours une valeur de "0" au début de l'animation, de "50" après huit secondes et de "100" à la fin de l'animation. Par contre, les valeurs de l'attribut keySplines définissent une courbe afin de réguler l'interpolation entre les valeurs. Dans l'exemple précédent, la spline produit un effet d'entrée et de sortie en douceur entre les temps 0 et 8 secondes (c'est-à-dire entre les valeurs d'attribut keyTimes "0" et ".8", et les valeurs de l'attribut values "0" et "50"), mais une interpolation linéaire stricte entre le temps 8 secondes et la fin (c'est-à-dire entre les valeurs d'attribut keyTimes ".8" et "1", et les valeurs de l'attribut values "50" et "100"). Cf. la figure 2 ci-dessous pour une illustration des courbes définies par ces valeurs d'attribut keySplines.

Pour certains attributs, les lecteurs ne discerneront peut-être pas aisément le rythme de changement. Par contre, pour les animations comme les mouvements, la possibilité de changer graduellement, et non pas de façon abrupte, la vitesse du mouvement peut être importante. L'attribut keySplines permet ce contrôle.

La figure suivante illustre l'interprétation de l'attribut keySplines. Chaque diagramme montre l'effet du paramétrage de keySplines sur un seul intervalle (c'est-à-dire entre les couples de valeurs associés dans les listes des attributs keyTimes et values). On peut assimiler l'axe horizontal à la valeur d'entrée de la progression unitaire de l'interpolation dans l'intervalle, c'est-à-dire le rythme auquel l'interpolation avance au long de l'intervalle en question. L'axe vertical représente la valeur résultante de la progresssion unitaire produite par la fonction keySplines. Décrit autrement, l'axe horizontal représente le temps unitaire en entrée de l'intervalle, et l'axe vertical le temps unitaire en sortie. Cf. également la section La temporisation et les temps d'horloge du monde réel.

Exemple keySplines01 - keySplines de 0 0 1 1 (par défaut) keySplines="0 0 1 1" (par défaut) Exemple keySplines02 - keySplines de .5 0 .5 1 keySplines=".5 0 .5 1"
Exemple keySplines03 - keySplines de 0 .75 .25 1 keySplines="0 .75 .25 1" Exemple keySplines04 - keySplines de 1 0 .25 .25 keySplines="1 0 .25 .25"
Figure 2: Illustration de l'effet de l'attribut keySplines

Pour illuster les calculs, considérons l'exemple simple suivant :

<animate dur="4s" values="10; 20" keyTimes="0; 1"
     calcMode="spline" keySplines={selon le tableau} />

En utilisant les valeurs d'attribut keySplines pour chacun des quatre cas ci-dessus, les valeurs interpolées approximatives au fur et à mesure de l'animation sont les suivantes :

Valeurs 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

Cf. [COMP-GRAPHICS] pour la définition formelle du calcul d'une spline de Bézier.

On peut aussi utiliser les attributs keyTimes et keySplines avec les formes abrégées from/to/by pour la définition 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 la courbe entré/sortie en douceur définie par les valeurs d'attribut keySplines. Les valeurs keyTimes amèneront la valeur de "20" à sept secondes, où elle se tiendra pour le restant de la durée simple de dix secondes.

L'exemple suivant décrit une utilisation quelque peu inhabituelle : une animation from-to avec animation discrète. L'attribut stroke-linecap des éléments SVG prend une valeur de type chaîne, ce qui implique donc un mode d'interpolation "discrete". L'animation fixera la valeur de la propriété stroke-linecap à "round" pendant cinq secondes (la moitié de la durée simple), puis à "square" pendant cinq secondes.

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

3.3. La définition de l'effet d'animation F(t)

Comme décrit précédemment, la fonction d'animation f(t) définition l'animation de la durée simple. Toutefois, la spécification SMIL Animation permet à l'auteur de répéter la durée simple. Elle permet aussi à l'auteur d'indiquer si l'animation devrait simplement s'arrêter lorsque la durée active se termine, ou si elle devrait être figée à la dernière valeur. En outre, l'auteur peut indiquer comment chaque animation devrait se combiner avec les autres animations et la valeur DOM originale.

Cette section décrit la syntaxe et la sémantique associée de cette fonctionnalité supplémentaire. On décrit un modèle détaillé de combinaison des animations avec des informations supplémentaires sur le modèle de temporisation.

La période de temps pendant laquelle l'animation est effectivement jouée, y compris les répétitions, est appelée la durée active. La durée active peut être calculée d'après la durée simple et la définition de répétition, et elle peut être contrainte par l'attribut end. Les règles de calcul complètes de la durée active sont présentées dans la section Le calcul de la durée active.

3.3.1. La répétition des animations

La répétition d'une animation entraîne la lecture plusieurs fois de suite de la fonction d'animation f(t). L'auteur peut indiquer combien de fois la répéter avec l'attribut repeatCount, ou bien combien de temps la répéter avec l'attribut repeatDur. Chaque itération de répétition est une instance de lecture de la fonction d'animation f(t).

Si la durée simple n'est pas définie, l'animation ne peut pas se répéter. Cf. également la section Le calcul de la durée active.

repeatCount
Indique le nombre d'itérations de la fonction d'animation. Cet attribut admet les valeurs suivantes :
une valeur numérique
Le nombre d'itérations est indiqué par une valeur numérique en virgule flottante (base 10). Elle peut inclure des itérations partielles exprimées en valeurs fractionnelles. Une valeur fractionnelle décrit une partie de la durée simple. La valeur doit être supérieure à 0.
"indefinite"
L'animation est définie pour se répéter indéfiniment (c'est-à-dire jusqu'à ce que le document se termine).
repeatDur
Indique la durée totale de la répétition. Cet attribut admet les valeurs suivantes :
Clock-value
Indique la durée dans le temps de présentation pendant laquelle répéter la fonction d'animation f(t).
"indefinite"
L'animation est définie pour se répéter indéfiniment (c'est-à-dire jusqu'à ce que le document se termine).

On devrait définir l'un des attributs repeatCount ou repeatDur au plus. Si les deux sont définis (et que la durée simple n'est pas "indefinite"), alors la durée active est définie comme le minimum entre la valeur de repeatDur et la durée simple multipliée par la valeur de repeatCount. Pour les besoins de cette comparaison, une valeur définie est censée être inférieure à la valeur "indefinite". Si la durée simple n'est pas définie et si les deux attributs repeatCount et repeatDur sont indiqués, l'attribut repeatCount sera ignoré et l'attribut repeatDur utilisé (cf. les exemples à suivre décrivant l'attribut repeatDur et une durée simple non définie). Ces règles sont incluses dans la section Le calcul de la durée active.

Exemples

Dans l'exemple suivant, la fonction d'animation de 2.5 secondes se répétera deux fois, et la durée active sera de 5 secondes.

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

Dans l'exemple suivant, la fonction d'animation se répétera deux fois entièrement, puis sa première moitié sera répétée une fois de plus, et 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 se répétera pendant un total de 7 secondes. Elle sera lue entièrement deux fois, et suivie par une partie fractionnaire de 2 secondes. Cela équivaut à une valeur de "2.8" pour l'attribut repeatCount. La dernière itération (partielle) appliquera des valeurs dans l'intervalle "0" à "8".

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

Remarquez que si la durée simple n'est pas définie (par exemple, sa valeur est "indefinite), alors le comportement de répétition n'est pas défini (mais l'attribut repeatDur définit toujours la durée active). Dans l'exemple suivant, la durée simple n'est pas définie, et l'attribut repeatCount est effectivement ignoré. Néanmoins, cela ne constitue pas une erreur : la durée active est également indéfinie. L'effet de l'animation consiste juste à utiliser la valeur de f(0), en fixant la couleur de l'attribut fill à "red" pour le restant de la durée du document.

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

Dans l'exemple suivant, la durée simple n'est pas définie, mais l'attribut repeatDur détermine toujours la durée active. L'effet de l'animation consiste à fixer la couleur de l'attribut fill à "red" pendant 10 secondes.

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

Dans l'exemple suivant, la durée simple est supérieure à la durée indiquée par l'attribut repeatDur, et la durée active raccourcira donc effectivement la durée simple. Toutefois, la fonction d'animation continue l'interpolation en utilisant la durée simple indiquée. L'effet de l'animation consiste à interpoler la valeur de l'attribut top de "10" à "17" au cours de 7 secondes.

<animate attributeName="top" from="10" to="20" 
    dur="10s" repeatDur="7s" />
L'attribut min et la relance

L'attribut min n'empêche pas la relance de l'élément avant que la durée active minimum ne soit atteinte.

Le contrôle du comportement d'une animation à répétition — L'animation cumulative

L'auteur peut aussi choisir qu'une animation à répétition devrait répéter le comportement original à chaque itération, ou bien qu'elle devrait ajouter au résultat précédent, accumulant à chaque itération. Par exemple, un tracé de mouvement décrivant un arc peut se répéter en se déplaçant sur le même arc, encore et encore, ou bien peut débuter chaque itération de répétition là où la dernière s'est arrêtée, en faisant rebondir l'élément animé à travers la fenêtre. On l'appelle une animation cumulative.

En utilisant la notation de tracé d'un arc simple (précisée dans la section L'élément animateMotion), on décrit cet exemple ainsi :

<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 depuis la position originale le long de l'arc au cours de 5 secondes. Lorsque l'animation se répète, elle repart de la valeur précédente et commence le deuxième arc là où s'est achevé le premier, comme illustré dans la figure 3 ci-dessous. Ainsi, l'image rebondit à travers l'écran. On pourrait décrire la même animation par un tracé totalisant quatre arcs, mais dans le cas général la description des tracés peut devenir très volumineuse et malaisée à créer.

Diagramme montrant une animation cumulative

Figure 3 : Illustration d'une animation à répétition avec accumulate="sum". Chaque itération de répétition ajoute à la précédente.

Remarquez que l'animation cumulative contrôle seulement la façon dont une seule animation accumule les résultats de la fonction d'animation au fur et à mesure qu'elle se répète. Elle ne contrôle pas en particulier comme 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.

Le comportement cumulatif des animations à répétition est contrôlé par l'attribut accumulate :

accumulate = "none | sum"
Contrôle si l'animation est cumulative ou non.
Pour la valeur "sum", chaque itération de répétition ajoute à la dernière valeur de l'itération précédente.
Pour la valeur "none", les itérations de répétition ne sont pas cumulatives et répètent simplement la fonction d'animation f(t). C'est la valeur par défaut.

Cet attribut est ignoré si l'attribut cible ne gère pas l'addition, ou si l'élément d'animation ne se répète pas.

L'animation cumulative n'est pas définie pour une animation to. Cet attribut sera ignoré si la fonction d'animation est seulement définie par l'attribut to. Cf. également la section Les valeurs de la fonction d'animation.

Tout attribut numérique gérant l'addition gère l'animation cumulative. Par exemple, on peut définir une animation palpitante qui augmentera de 100 pixels en 50 secondes l'attribut width d'un élément SVG rect.

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

Chaque durée simple gonfle la largeur du rectangle de 15 pixels puis la dégonfle pour la laisser 10 pixels plus grande. La forme fait 20 pixels de large au début et 30 pixels après 5 secondes. L'animation se répète et ajoute aux valeurs précédentes. La forme gonflera à 45 pixels pour revenir à 40 pixels après 10 secondes, et finira éventuellement à 120 pixels (20+120) de large au bout de toutes les dix répétitions.

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

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

Le rectangle grandira de 10 à 20 pixels au cours des cinq premières secondes, puis de 20 à 30 pixels, au cours des cinq suivantes, et ainsi de suite jusqu'à 110 pixels au terme des dix répétitions. Remarquez, comme la valeur par défaut de l'attribut additive est "replace", que la valeur originale est ignorée. L'exemple suivant rend l'animation explicitement 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êmes que précédemment, à la différence que toutes les valeurs se sont déplacées vers le haut depuis la valeur originale de "20px". Le rectangle fait 30 pixels de large après cinq secondes et 130 pixels au terme des dix répétitions.

Le calcul des valeurs de l'animation cumulative

Pour produire le comportement d'animation cumulative, on doit modifier légèrement la fonction d'animation f(t). Chaque itération après la première doit ajouter la dernière valeur de l'itération précédente (on l'exprime comme un multiple de la dernière valeur indiquée pour la fonction d'animation. Remarquez que l'animation cumulative est définie en fonction des valeurs indiquées du comportement d'animation, et non en fonction des valeurs d'animation échantillonnées ou rendues. Les dernières varieraient d'une machine à l'autre, et même pourraient varier entre les vues de documents sur la même machine.

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

La première itération f0(t), non affectée par l'attribut accumulate, est donc la même que la définition de la fonction d'animation originale.

f0(t) = f(t)

Soit ve la dernière valeur définie pour la fonction d'animation (par exemple, la valeur de l'attribut to, la dernière valeur d'une liste values ou la valeur finale d'un attribut path). Chaque itération après la première ajoute le décalage calculé :

fi(t) = (ve * i) + f(t) ; i >= 1

3.3.2. Le contrôle de la durée active

La spécification SMIL Animation fournit un contrôle supplémentaire de la durée active. L'attribut end permet à l'auteur de contraindre la durée active de l'animation en indiquant une valeur de fin, avec un décalage simple, une base de temps, une base d'événement ou l'appel de méthodes DOM. L'attribut end peut contraindre mais pas étendre la durée active définie par ailleurs par un attribut dur et un comportement de répétition éventuel. Les règles de combinaison des attributs pour le calcul de la durée active sont présentées dans la section Le calcul de la durée active.

end
Définit une valeur de fin de l'animation qui peut contraindre la durée active.
La valeur de l'attribut se compose d'une liste de valeurs, séparées par des points-virgules.
end-value-list : end-value (";" end-value-list )?
Une liste de valeurs de fin, séparées par des points-virgules. L'interprétation d'une liste de valeurs de fin est précisée dans la section L'évaluation des listes de temps de début et de fin.
end-value : ( offset-value | syncbase-value | event-value | repeat-value | accessKey-value | media-marker-value | wallclock-sync-value | "indefinite" )
Décrit la valeur de fin.
offset-value : ( "+" | "-" )? Clock-value
Indique le temps de présentation de la fin. La valeur de fin est donc définie relativement au début du document.
syncbase-value : ( Id-value "." ( "begin" | "end" ) ) ( ( "+" | "-" ) Clock-value )?
Décrit une base de synchronisation et un décalage par rapport à cette base de synchronisation. La valeur de fin est définie relativement au début ou à la fin active d'un autre élément.
event-value : ( Id-value "." )? ( event-ref ) ( ( "+" | "-" ) Clock-value )?
Décrit un événement et un décalage optionnel qui déterminent le début de l'élément. La valeur de fin de l'animation est définie par rapport au temps où l'événement est suscité. Les événements peuvent être tous ceux définis pour le langage hôte, conformément à [DOM2Events]. Ils peuvent comprendre les événements de l'interface utilisateur, les déclencheurs d'événements transmis via un réseau, etc. Les détails de la temporisation basée sur les événements sont décrits dans la section L'unification de la temporisation interactive et de la temporisation programmée ci-dessous.
repeat-value : ( Id-value "." )? "repeat(" integer ")" ( ( "+" | "-" ) Clock-value )?
Décrit un événement de répétition qualifié. La valeur de fin est définie par rapport au temps où l'événement de répétition est suscité avec la valeur d'itération spécifiée.
accessKey-value : "accessKey(" character ")"
Décrit une clé d'accès qui détermine la valeur de fin. La valeur de fin est définie par rapport au temps où le caractère de clé d'accès est saisi par l'utilisateur.
wallclock-sync-value : "wallclock(" wallclock-value ")"
Décrit la valeur de fin comme un temps d'horloge du monde réel. La syntaxe du temps d'horloge est basée sur celle définie dans [ISO8601].
"indefinite"
La valeur de fin de l'animation sera déterminée par un appel de la méthode endElement() (ou un équivalent).
Les méthodes DOM de SMIL Animation sont décrites dans la section Les interfaces prises en charge.
La temporisation basée sur les hyperliens est décrite dans la section Les hyperliens et la temporisation.

La valeur de l'attribut end peut définir une liste de temps. On peut la mettre à profit pour indiquer plusieurs façons ou règles de terminer un élément, par exemple, si l'un de plusieurs événements a lieu. Une liste de temps peut également définir plusieurs temps de fin pouvant correspondre à plusieurs temps de début, permettant une lecture à plusieurs reprises de l'élément (ce comportement est contrôlable, cf. également la section La relance des animations).

Exemples

Dans l'exemple suivant, la durée active se terminera au premier arrivé entre les dix secondes et la fin de l'élément foo. Cela est particulièrement utile si foo est défini pour débuter ou finir relativement à un événement.

<animate dur="2s" repeatDur="10s" end="foo.end" ... />

Dans l'exemple suivant, l'animation débute lorsque l'utilisateur clique sur l'élément cible. La durée active s'achèvera 30 secondes après que le document a commencé. Remarquez que, si l'utilisateur n'a pas cliqué sur l'élément cible avant l'écoulement des 30 secondes, alors l'animation ne débutera jamais.

<animate begin="click" dur="2s" repeatDur="indefinite"
         end="30s" ... />

L'utilisation de l'attribut end avec une valeur d'événement permet aux auteurs de terminer une animation en fonction soit d'un événement interactif, soit d'une durée active maximum. On l'appelle parfois une interaction paresseuse.

Dans cet exemple, une présentation décrit un processus de montage. Elle utilise une animation pour déplacer une image alentour (par exemple, contre un arrière-plan), pour montrer comment un objet se déplace d'une partie d'un montage à l'autre. Chaque étape est un tracé de mouvement réglé pour se répéter trois fois pour illustrer clairement le point. Chaque animation peut également être arrêtée en cliquant sur un élément next, ce qui permet à l'utilisateur d'avancer la présentation à l'étape suivante.

<img id="objectToMove" ... >
  <animateMotion id="step1" begin="0" dur="5s"
     repeatCount="3" end="next.click" path.../>
  <animateMotion id="step2" begin="step1.end" dur="5s"
     repeatCount="3" end="next.click" path.../>
  <animateMotion id="step3" begin="step2.end" dur="5s"
     repeatCount="3" end="next.click" path.../>
  <animateMotion id="step4" begin="step3.end" dur="5s"
     repeatCount="3" end="next.click" path.../>
  <animateMotion id="step5" begin="step4.end" dur="5s"
     repeatCount="3" end="next.click" path.../>
</img>

Ici la fin active de chaque animation est définie comme le premier arrivé entre les 15 secondes après son début et un clic sur next. Le spectateur a le choix entre s'installer confortablement et regarder la présentation, ou la faire défiler plus vite.

3.3.3. Les attributs min et max : encore plus de contrôle sur la durée active

Cette section est informative

Les attributs min et max permettent à l'auteur de contrôler la limite inférieure et la limite supérieure de la durée active de l'élément.

Cette section est normative

min
Indique la valeur minimum de la durée active.
La valeur de l'attribut peut être l'une des suivantes :
Clock-value
Définit la longueur de la valeur minimum de la durée active, mesurée dans le temps actif de l'élément.
La valeur doit être supérieure ou égale à 0.
"media"
Définit la valeur minimum de la durée active comme étant la durée intrinsèque du média. Ce n'est valable que pour les éléments définissant un média.

S'il y a une erreur dans la syntaxe de la valeur d'argument de min, l'attribut sera ignoré (comme s'il n'avait pas été défini).

La valeur par défaut de l'attribut min est "0". Elle ne contraint pas du tout la durée active.

max
Définit la valeur maximum de la durée active.
La valeur de l'attribut peut être l'une des suivantes :
Clock-value
Définit la longueur de la valeur maximum de la durée active, mesurée dans le temps actif de l'élément.
La valeur doit être supérieure à 0.
"media"
Définit la valeur maximum de la durée active comme étant la durée intrinsèque de l'élément. Ce n'est valable que pour les éléments définissant un média.
"indefinite"
La valeur maximum de la durée est indéfinie et n'est donc pas contrainte.

S'il y a une erreur dans la syntaxe de la valeur d'argument de max, l'attribut sera ignoré (comme s'il n'avait pas été défini).

La valeur par défaut de l'attribut max est "indefinite". Elle ne contraint pas du tout la durée active.

Si la valeur d'argument "media" est indiquée pour l'un des attributs min ou max sur un élément ne définissant pas de média, alors l'attribut concerné sera ignoré (comme s'il n'avait pas été défini).

Si les deux attributs min et max sont définis, alors la valeur de l'attribut max doit être supérieure ou égale à celle de l'attribut min. Si cette condition n'est pas remplie, les deux attributs sont ignorés.

La règle à suivre pour calculer la durée active lorsque les attributs min ou max sont définis est la suivante. À chaque calcul de la durée active d'un élément (c'est-à-dire pour chaque intervalle de l'élément s'il débute plusieurs fois), le calcul a lieu sans tenir compte des attributs min et max (en appliquant l'algorithme décrit dans la section Le calcul de la durée active). Le résultat obtenu à la suite de cette étape est comparé aux limites indiquées par les attributs min et max. Si le résultat se situe entre ces limites, alors la première valeur calculée est correcte. Sinon deux cas peuvent se produire :

L'attribut min et les temps de début négatifs

Si un élément est défini pour débuter avant son parent (par exemple, avec une valeur de décalage négative simple), la durée de l'attribut min est mesuré depuis le temps de début calculé, et non depuis le début observé (cf. l'exemple 1 ci-dessous). La valeur de l'attribut min peut donc n'avoir aucun effet.

Cf. également la section L'attribut min et la relance.

3.3.4. Le calcul de la durée active

Le tableau de la figure 4 présente la sémantique de toutes les combinaisons de durée simple possibles avec les attributs repeatCount et repeatDur, et l'attribut end. Les conventions utilisées dans le tableau sont les suivantes :

En outre, on doit suivre les règles suivantes pour le calcul des valeurs :

Les règles et résultats implicites dans le tableau à noter en particulier sont les suivants :

Le tableau utilise les symboles suivants :

B
Le début d'une animation.
d
La durée simple d'une animation.
Durée simple d repeatCount repeatDur end Durée active
définie d
définie défini repeatCount*d
définie défini repeatDur
définie défini MIN( d, end-B )
définie défini défini MIN( repeatCount*d, repeatDur )
définie défini défini MIN( repeatCount*d, ( end-B ))
définie défini défini MIN( repeatDur, ( end-B ))
définie défini défini défini MIN( repeatCount*d, repeatDur, ( end-B ))
non définie * indefinite
non définie * défini repeatDur
non définie * défini end-B
non définie * défini défini MIN( repeatDur, ( end-B ))
* non défini non définie
* non défini non définie
* non défini non défini non définie
* non défini défini end-B
* non défini défini end-B
* non défini non défini défini end-B
Figure 4 : Calcul de la durée active de différentes combinaisons de durée simple, d'attributs repeatCount et repeatDur, et d'attribut end

3.3.5. Le figeage des animations

Par défaut, lorsque 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 qu'elle se termine, l'image rebondira en arrière à sa position originale.

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

L'image sera immobile à top valant "3" pendant cinq secondes puis elle se déplacera de 100 pixels vers le bas en 10 secondes. L'animation s'achèvera quinze secondes après le début du document, l'effet n'étant plus appliqué, l'image bondira en arrière de "103" à "3" d'où elle a démarré (c'est-à-dire la valeur sous-jacente de l'attribut top).

On peut utiliser l'attribut fill pour conserver la valeur de l'animation après que la durée active de l'animation est terminée :

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

L'animation se termine 15 secondes après le début du document mais l'image reste à top valant "103". L'attribut gèle la dernière valeur de l'animation pour le restant de la durée du document.

Le comportement de figeage d'une animation est contrôlé par l'attribut fill :

fill = "freeze | remove"
Cet attribut admet les valeurs suivantes :
"freeze"
L'effet d'animation F(t) est défini pour figer la valeur d'effet à la dernière valeur de la durée active. L'effet d'animation est figé pour le restant de la durée du document (ou jusqu'à ce que l'animation soit relancée, cf. la section La relance des animations).
"remove"
L'effet d'animation est supprimé (il n'est plus appliqué) lorsque la durée active de l'animation est terminée. Après la fin active de l'animation, l'animation n'affecte plus la cible (à moins que l'animation ne soit relancée, cf. la section La relance des animations).
C'est la valeur par défaut.

Si la durée active raccourcit la durée simple (y compris les cas à répétition partielle), la valeur d'effet d'une animation figée est définie par cette durée simple raccourcie. Dans l'exemple suivant, la fonction d'animation se répéte deux fois entièrement et encore une fois de la moitié de la durée simple. Auquel cas, la valeur figée sera de "15" :

<animate from="10" to="20" dur="4s" 
         repeatCount="2.5" fill="freeze" .../>

Dans l'exemple suivant, l'attribut dur est absent, et la durée simple n'est donc pas définie. La durée active est contrainte par l'attribut end pour être de 10 secondes. Puisque l'interpolation n'est pas définie, la valeur figée sera de "10" :

<animate from="10" to="20" end="10s" fill="freeze" .../> 
La comparaison avec la temporisation SMIL

La spécification SMIL Animation indique que fill="freeze" est en vigueur pour le restant du document, ou jusqu'à la relance de l'élément. Dans le modèle de temporisation plus général de SMIL, avec des conteneurs de temps, la durée de l'effet de figeage est contrôlée par le conteneur de temps, et ne s'étend jamais au-delà de la fin de la durée simple du conteneur de temps. Quoique cela puisse sembler contradictoire, la définition SMIL Animation de fill="freeze" est cohérente avec le modèle de temporisation SMIL. Dans SMIL Animation, le document représente tout simplement le seul conteneur de temps, et l'effet est donc celui décrit précédemment.

3.3.6. L'animation additive

Il est souvent pratique de définir une animation comme un décalage ou delta par rapport à la valeur d'un attribut plutôt qu'avec des valeurs absolues. Une simple animation d'agrandissement 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 commence à 20 pixels et augmente jusqu'à 30 pixels au cours de 10 secondes. Si l'animation était déclarée non additive, les mêmes valeurs from et to donneraient une largeur allant de 0 à 10 pixels pendant les 10 secondes.

En outre, beaucoup d'animations complexes s'expriment mieux comme des combinaisons d'animations simples. Par exemple, on peut décrire un tracé vibrant comme un mouvement répétitif de haut en bas associé à un 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>

Lorsque plusieurs animations définies pour un attribut donné se chevauchent à un moment, elles se combinent, ou bien l'une prend le pas sur l'autre. Les animations se chevauchent lorsqu'elles sont actives ou bien figées au même moment. L'ordre des animations (par exemple, quelle animation remplace telle autre) est déterminé par une priorité associée à chaque animation. La priorité des animations dépend du moment où chacune débute. La première animation à débuter a la priorité la plus faible et la dernière la priorité la plus élevée.

Les animations de priorité supérieure non additives remplaceront toutes les animations antérieures (de priorité moindre) et fixeront simplement la valeur de l'attribut. Les animations additives s'appliquent (c'est-à-dire ajoutent) au résultat des animations activées avant. Cf. la section Le modèle d'animation en sandwich pour des précisions sur la combinaison des animations.

Le comportement additif d'une animation est contrôlé par l'attribut additive :

additive = "replace | sum"
Contrôle si l'animation est additive ou non.
"sum"
Indique que l'animation ajoutera à la valeur sous-jacente de l'attribut et des autres animations de priorité inférieure.
"replace"
Indique que l'animation remplacera la valeur sous-jacente de l'attribut et des autres animations de priorité inférieure. C'est la valeur par défaut. Toutefois, le comportement est également affecté par les valeurs des attributs by et to de l'animation, comme décrit ci-dessous.

L'animation additive est définie pour les attributs numériques et les autres types de données pour lesquels une fonction d'addition est définie. Cela comprend les attributs numériques de concepts comme la position, les largeurs, les hauteurs, les dimensions, etc. Cela inclut aussi la couleur (cf. la section L'élément animateColor) et peut inclure d'autres types de données comme défini par le langage hôte.

Il est souvent pratique de combiner des animations additives et le comportement de l'attribut fill, par exemple lorsqu'on définit une série de mouvements qui devraient ajouter à un autre :

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

L'image bouge le long du premier tracé puis entame le deuxième tracé à la fin du premier, suit ensuite le troisième tracé à la fin du deuxième et reste enfin au point final.

Quoique beaucoup d'animations d'attributs numériques seront additives, ce ne sera pas toujours le cas. Comme exemple d'animation définie comme non additive, considérons une animation d'extension hypothétique mouseFollow où un objet poursuit la souris.

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

L'animation de poursuite de souris joue pendant 5 secondes à chaque fois que l'utilisateur déplace la souris sur l'image. Elle ne peut pas être additive, ou elle décalera le tracé de mouvement de façon étrange. Il faut que l'élément mouseFollow remplace l'élément animateMotion tant qu'il est actif. Lorsque l'élément mouseFollow se termine, son effet n'est plus appliqué et l'élément animateMotion reprend le contrôle de la valeur de présentation de la position.

En outre, certains attributs numériques (par exemple, un attribut de numéro de téléphone) ne géreront raisonnablement pas l'addition, le langage hôte a la responsabilité de définir quels attributs gèrent l'animation additive. Les types d'attribut comme les chaînes et les booléens, pour lesquels l'addition n'est pas définie, ne peuvent pas gérer l'animation additive.

Comment les attributs from, to et by affectent-ils le comportement additif

Les valeurs des attributs to et by utilisées pour décrire la fonction d'animation, peuvent remplacer l'attribut additive dans certains cas :

Dans le cas hybride d'animation to, la fonction d'animation f(t) est définie en fonction de la valeur sous-jacente, de la valeur de l'attribut to et de la valeur courante t c'est-à-dire le temps) relative à la durée simple d.

d
est la durée simple
t
est un temps compris dans la durée simple (0 <= t <= d)
vcur
est la valeur de base courante (au temps t)
vto
est la valeur définie de l'attribut to

f(t) = vcur + ((vto - vcur) * (t/d))

Remarquez que si aucune autre animation (de priorité moindre) n'est active ou figée, cela définit une interpolation simple. Par contre, si une autre animation est en train de manipuler la valeur de base, l'animation to ajoutera à l'effet de cette animation de priorité moindre, mais la dominera à l'approche de la fin de la durée simple pour éventuellement la remplacer complètement. La valeur de l'effet d'animation F(t) lorsqu'une animation to est figée (à la fin de la durée simple) correspond simplement à la valeur de l'attribut to. Si une animation to est figée, où que ce soit dans la durée simple (par exemple, en utilisant un attribut repeatCount avec une valeur de "2.5"), la valeur de l'effet d'animation F(t) lorsque l'animation est figée correspond à la valeur calculée pour la fin de la durée active. Même si d'autres animations de priorité moindre sont actives au figeage d'une animation to, la valeur de l'effet d'animation F(t) ne change pas.

Plusieurs animations to se combineront de même conformément à cette sémantique. L'animation de priorité supérieure l'emportera et, en fin de compte, c'est elle qui fixera la valeur finale de l'attribut.

Plusieurs animations by se combineront conformément aux règles générales de l'animation additive et du modèle d'animation en sandwich.

L'utilisation de valeurs d'attribut from n'implique pas d'animation additive ou d'animation non additive, et les deux sont possibles. La valeur de l'attribut from d'une animation additive s'ajoute simplement à la valeur sous-jacente, tout comme pour la valeur initiale des animation définies par une liste values. Le comportement additif des animations from to et from by est contrôlé par l'attribut additive, comme dans le cas général.

Comme exemple d'animation to additive, considérons les deux animations additives suivantes. La première, une animation by, applique un delta de 0 à -10 sur l'attribut x. La seconde, une animation to, l'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>

On donne la valeur de présentation de l'attribut x de l'exemple précédent au cours de 10 secondes dans la figure 5 ci-dessous. Ces valeurs sont simplement calculées avec la formule décrite précédemment. Remarquez que la valeur de l'effet d'animation F(t) de A2 est la valeur de présentation de l'attribut x.

Temps F(t) de A1 F(t) de 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
Figure 5 : Effet de l'exemple d'animation to additive
L'animation additive et l'animation cumulative

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

Les auteurs s'attendent habituellement à ce que les animations cumulatives soient additives (comme dans les exemples décrits précédemment pour l'attribut accumulate), mais ce n'est pas obligatoirement le cas. L'exemple suivant est cumulatif mais pas additif.

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

L'animation remplace la valeur originale fixée pour l'attribut "top", quelle qu'elle soit, et débute à la valeur "20". Il se produit un déplacement de 10 pixels jusqu'à la valeur "30" qui se répète. L'animation est cumulative et la deuxième itération débute donc à "30" et se déplace de dix autres pixels jusqu'à "40". Etc.

Lorsqu'une animation cumulative est aussi définie comme additive, les deux caractéristiques fonctionnent normalement. L'effet cumulé de F(t) sert de valeur à l'animation et s'ajoute à la valeur sous-jacente de l'attribut cible. Cf. également la section Le modèle d'animation en sandwich.

3.3.7. La relance des animations

Lorsqu'une animation est définie pour débuter à un décalage simple (par exemple begin="5s"), il n'y a aucune ambiguïté concernant le temps où l'élément débute. Par contre, si une animation est définie pour débuter relativement à un événement (par exemple, begin="foo.click"), l'événement peut advenir à tout moment voire plusieurs fois (par exemple, si l'utilisateur clique sur foo plusieurs fois). Dans certains cas, il est souhaitable de relancer l'animation lorsqu'un deuxième événement est reçu. Dans d'autres cas, l'auteur souhaitera peut-être empêcher ce comportement. L'attribut restart contrôle les conditions de relance d'une animation :

restart = "always | whenNotActive | never"
"always"
L'animation peut être relancée à tout moment.
C'est la valeur par défaut.
"whenNotActive"
L'animation peut seulement être relancée si elle n'est pas active (c'est-à-dire qu'elle peut l'être après la fin active). Les tentatives de relance de l'animation pendant sa durée active sont ignorées.
"never"
L'animation ne peut pas être relancée pour le restant de la durée du document.

Remarquez qu'une animation peut être relancée de plusieurs façons. Dans tous les cas, le comportement (c'est-à-dire la relance ou non) est contrôlé par l'attribut restart. Les différents cas de relance sont les suivants :

Lorsqu'une animation est relancée, la sémantique déterminante est telle que l'animation se comporte comme s'il s'agissait de sa première lecture, indépendamment de tout comportement précédent. L'effet d'animation F(t) est défini indépendamment du comportement de relance. L'effet d'une éventuelle animation lue avant n'est plus appliqué et seul l'effet d'animation F(t) courant l'est.

Si une animation additive est relancée alors qu'elle est active ou bien figée, l'effet d'animation précédent (c'est-à-dire avant la relance) n'est plus appliqué sur l'attribut. Remarquez en particulier qu'une animation cumulative n'est définie que dans la durée active d'une animation. Lorsqu'une animation est relancée, tout le contexte accumulé est supprimé et l'effet d'animation F(t) recommence l'accumulation dès la première itération de la durée active relancée.

Lorsqu'un élément actif est relancée, l'élément termine d'abord la durée active, qu'il propage ensuite aux dépendants temporels, et suscite un événement endEvent de la façon habituelle (cf. également la section L'évaluation des listes de temps de début et de fin).

Cf. la section L'évaluation des listes de temps de début et de fin pour des précisions à propos de quand et comment l'attribut restart est évalué.

Remarquez que l'auteur peut également définir en utilisant l'attribut restart un seul événement d'interface utilisateur pour débuter ou terminer un élément, comme suit :

<img ...>
   <animate id="foo" begin="click" dur="2s"
       repeatDur="indefinite" end="click"
       restart="whenNotActive" ... />
</img>

Si l'élément foo avait été défini avec le comportement de relance par défaut ("always"), un deuxième clic sur l'image aurait simplement relancé l'animation. Toutefois, puisque le deuxième clic ne peut pas relancer l'animation lorsque l'attribut restart vaut "whenNotActive", le clic terminera simplement la durée active et arrêtera l'animation. On l'appelle parfois une activation bascule. Cf. également les sections La sensibilité de l'événement et L'unification de la temporisation interactive et de la temporisation programmée.

La réinitialisation de l'état de l'élément

Cette section est normative

Lors de la relance d'un élément, un certain état est réinitialisé :

La comparaison avec la temporisation SMIL

La spécification SMIL Animation indique qu'avec restart="never" la relance est empêchée pour le restant de la durée du document. Dans le modèle de temporisation plus général de SMIL 2.0 [SMIL20], avec des conteneurs de temps, la durée de la sémantique de restart="never" est définie par le conteneur de temps et elle ne s'étend que jusqu'à la fin de la durée simple du conteneur de temps. Quoique cela puisse sembler contradictoire, la définition SMIL Animation pour restart="never" est cohérente avec le modèle de temporisation SMIL. Dans SMIL Animation, le document représente tout simplement le seul conteneur de temps, et l'effet est donc celui décrit précédemment.

3.4. Le traitement des erreurs de syntaxe

Les mécanismes de traitement des erreurs spécifiques de chaque attribut sont décrits avec leur description syntaxique individuelle. Certaines définitions décrivent le comportement d'animations avec des erreurs de syntaxe comme sans effet. Cela signifie que l'animation continuera à se comporter normalement en ce qui concerne la temporisation, mais elle ne manipulera pas de valeur de présentation et n'aura donc aucun impact visible sur la présentation.

En particulier, cela signifie que si d'autres éléments d'animation sont définis pour débuter ou finir relativement à une animation sans effet, ces autres éléments débuteront et finiront comme s'il n'y avait pas d'erreur de syntaxe. Le moteur de présentation peut signaler une erreur, mais il n'interrompra pas nécessairement la présentation ou l'animation du document.

Certains langages hôtes et/ou moteurs d'exécution peuvent choisir d'appliquer une gestion d'erreurs plus stricte (cf. également la section La sémantique du traitement des erreurs pour une explication des problèmes de langages hôtes avec le traitement des erreurs). Les environnements de création peuvent aussi opter pour une intervention plus opportune lorsque des erreurs sont détectées.

3.5. Le modèle d'animation en sandwich

Au cours de son exécution, l'animation ne change pas réellement les valeurs des attributs dans le DOM. Idéalement, le moteur d'animation devrait conserver une valeur de présentation de l'attribut cible, distincte du DOM, de CSS ou d'un autre modèle objet (OM) où 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 à agir sur les valeurs sous-jacentes DOM ou CSS OM.

Pour la suite de l'exposé, nous employons le terme générique OM pour désigner aussi bien le DOM de XML [DOM2Core] que le modèle objet CSS OM. Si une mise en œuvre ne gère pas un modèle objet, elle devrait idéalement conserver la valeur originale définie par le document ainsi que la valeur de présentation ; pour les besoins de cette section, nous tiendrons la valeur originale comme équivalente à celle du modèle objet (OM).

Pour certaines mises en œuvre DOM, il sera peut être difficile ou pas pratique de conserver la valeur de présentation définie précédemment. Les valeurs CSS devraient toujours être gérées comme décrites, puisque le modèle CSS OM offre un tel mécanisme. Pour les mises en œuvre qui ne permettent pas d'avoir des valeurs de présentation séparées des propriétés DOM XML générales, elles doivent au moins rétablir la valeur originale lorsque les animations n'exercent plus d'effet.

Le reste de cet exposé suppose l'approche recommandée avec une valeur de présentation séparée.

Le modèle rendant compte du modèle objet et des animations simultanément actives ou figées d'un attribut donné est décrit comme un sandwich, selon une vague analogie avec les couches de viande et de fromage d'un sandwich baguette (un sandwich allongé contenant plusieurs morceaux de viande et de fromage empilés sur la longueur du pain). Dans cette analogie, le temps correspond à la longueur du sandwich, et la durée de chaque animation est représentée par la longueur de pain occupée par la couche. Au fond du sandwich se trouve la valeur de base provenant du modèle objet. Chaque animation active (ou figée) est une couche venant par-dessus. Les couches (c'est-à-dire les animations) sont disposées sur le sandwich à la fois dans le temps (dans la longueur du pain) et en ordre de priorité, les animations de priorité plus élevée venant sur (c'est-à-dire au-dessus) celles de priorité moindre. À tout instant donné, on peut faire une coupe dans le sandwich et voir comment les couches d'animation s'empilent.

Remarquez que les animations manipulent la valeur de présentation issue du modèle objet où est défini l'attribut, et passent la valeur résultante à la couche suivante du traitement du document. La cascade de traitement normale du modèle objet du document n'est ni remplacée ni poussée au second plan.

En particulier, l'animation d'un attribut définit dans XML modifiera la valeur de présentation avant qu'elle ne passe à travers la cascade de feuilles de style, en utilisant comme base la valeur DOM XML. L'animation d'un attribut défini dans un langage de feuille de style modifiera la valeur de présentation passée au reste de la cascade.

Dans CSS2 et dans le modèle CSS OM de DOM 2, on emploie les termes spécifié, calculé et réel pour décrire les résultats d'évaluation de la syntaxe, de la cascade et du rendu de présentation. Lorsque l'animation s'applique aux propriétés CSS d'un élément particulier, la valeur de base à animer est lue en appliquant la méthode getComputedStyle() (en lecture seule) sur cet élément. Les valeurs produites par l'animation sont écrites dans la feuille de style de remplacement pour cet élément, que l'on peut obtenir avec la méthode getOverrideStyle(). Ces nouvelles valeurs affectent alors la cascade et elles sont reflétées dans une nouvelle valeur calculée (et donc dans une présentation modifiée). Cela signifie que l'effet de l'animation remplace toutes les règles de feuille de style, à l'exception des règles de l'utilisateur avec une propriété !important. Cela permet aux paramètres de style !important de l'utilisateur d'avoir priorité sur les animations, une condition primordiale de l'accessibilité. Remarquez que l'animation peut produire des effets secondaires sur la disposition du document. Cf. également les spécifications [CSS2] (les termes sont définis dans la section 6.1) et [DOM2CSS] (section 5.2.1).

Dans un modèle objet, les animations sont placées prioritairement selon le moment où elles débutent. La première animation commencée a la priorité la plus faible, et la dernière la plus haute. Lorsque deux animations débutent au même moment, l'ordre d'activation est résolu de la façon suivante :

Remarquez que si une animation est relancée (cf. également la section La relance des animations), elle se placera toujours en haut de la liste de priorité, puisque c'est la dernière animation activée. C'est-à-dire qu'à la relance d'une animation, sa couche est retirée du sandwich puis remise tout en haut. Par contre, si l'élément se répète, la priorité n'est pas affectée (un comportement de répétition n'est pas défini comme constituant une relance).

Chaque animation additive ajoute son effet au résultat de toutes les couches du sandwich placées en-dessous. Une animation non additive remplace 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 à refléter dans la vue de document.

Certains attributs gérant l'animation additive ont une gamme définie de valeurs légales (par exemple, un attribut d'opacité admettra des valeurs entre 0 et 1). Dans certains cas, une fonction d'animation peut produire des valeurs hors échelle. On recommande que les mises en œuvre forcent les résultats dans l'échelle légale le plus tard possible, avant de les appliquer à la valeur de présentation. Idéalement, on devrait combiner l'effet de toutes les animations actives ou figées à un point donné avant d'effectuer un forçage. Quoique des fonctions d'animation puissent produire individuellement des valeurs hors échelle, une combinaison d'animations additives peut quand même être légale. On tient compte de ces cas en forçant le seul résultat final et non l'effet des fonctions d'animation individuelles. Au besoin, on peut forcer les résultats intermédiaires quoique ce ne soit pas optimal. Le langage hôte doit définir la sémantique de forçage de chaque attribut animable. Cf. la section L'élément animateColor pour exemple.

Initialement, avant que les animations d'un attribut donné ne soient actives, la valeur de présentation sera identique à la valeur originale spécifiée dans le document (la valeur OM).

Lorsque toutes les animations d'un attribut donné sont terminées et que les effets d'animation ne sont plus appliqués, la valeur de présentation sera à nouveau égale à la valeur OM. Remarquez que si une animation est définie avec fill="freeze", l'effet d'animation s'appliquera aussi longtemps que le document sera affiché, et la valeur de présentation reflétera donc l'effet d'animation jusqu'à la fin du document. Cf. également la section Le figeage des animations.

Certaines animations (par exemple, avec l'élément animateMotion) viseront implicitement un attribut, ou éventuellement plusieurs (par exemple, les attributs posX et posY d'un certain modèle de disposition). On doit combiner ces animations à toutes les autres animations de chaque attribut affecté. Ainsi, par exemple, une animation animateMotion peut se trouver dans plusieurs sandwichs d'animations (selon le modèle de disposition du langage hôte). Pour les éléments d'animation visant implicitement des attributs, le concepteur du langage hôte doit définir quels attributs sont visés implicitement, et le moteur d'exécution doit en conséquence combiner les animations des attributs respectifs.

Remarquez que toutes les interrogations (via les interfaces DOM) à propos de l'attribut cible refléteront la valeur OM et non l'effet des animations. Remarquez aussi que la valeur OM peut toujours être changée via les interfaces du modèle objet (par exemple, avec un script). Quoiqu'un accès à la valeur de présentation finale, après application de tous les effets d'animation, puisse être utile ou souhaitable, SMIL Animation ne fournit pas d'interface de ce type. Une version future y répondra peut-être.

Bien que les animation ne manipulent pas les valeurs du modèle objet, l'affichage du document doit refléter les changements survenus sur les valeurs du modèle objet. Les langages hôtes peuvent gérer des langages de script capables de manipuler directement les valeurs des attributs dans le modèle objet. Si une animation est active ou figée alors qu'advient un changement de la valeur OM, le comportement dépend de la définition de l'animation, si elle est additive ou non (cf. également la section L'animation additive) :

3.6. Les détails du modèle de temporisation

3.6.1. La temporisation et les temps d'horloge du monde réel

Tout au long de cette spécification, l'animation est décrite comme une fonction du temps. Notamment, on décrit la fonction d'animation comme produisant une valeur pour n'importe quel temps dans l'intervalle de la durée simple. Toutefois, la durée simple peut se répéter, et l'animation débuter et être relancée de plusieurs façons. De ce fait, il n'y a aucune relation directe entre le temps utilisé par une fonction d'animation et la notion du temps dans le monde réel reflété par une horloge.

Lorsqu'un attribut keySplines sert à ajuster le rythme entre les valeurs d'une animation, on peut assimiler cette sémantique au changement de la vitesse du temps dans l'intervalle en question. Un modèle équivalent est celui où l'attribut keySplines change simplement le rythme de progression de l'interpolation dans l'intervalle donné. Les deux interprétations sont mathématiquement équivalentes, et le point signicatif est qu'on ne devrait pas interpréter le concept de temps défini pour la fonction d'animation f(t) comme le temps d'une horloge du monde réel.

3.6.2. La temporisation des intervalles

La spécification SMIL Animation suppose le modèle de temporisation d'intervalles le plus courant. Il décrit des intervalles de temps (c'est-à-dire des durées) où le temps de début de l'intervalle est inclus dans l'intervalle en question mais pas le temps de fin. On l'appelle aussi temporisation à point limite exclu. Ce modèle assure le fonctionnement arithmétique correct des intervalles, et il offre des modèles raisonnables pour les suite d'intervalles.

Les justifications documentaires

Dans le monde réel, cela équivaut à la manière dont les secondes s'ajoutent pour donner des minutes, et les minutes des heures. Bien qu'une minute soit décrite comme faisant 60 secondes, une horloge numérique n'indique jamais plus de 59 secondes. Ajouter une seconde à 00:59 ne donne pas 00:60 mais plutôt 01:00, soit une minute et zéro seconde. Le temps de fin des 60 secondes décrivant un intervalle d'une minute est exclu de l'intervalle réel.

Dans l'univers des médias et des lignes de temps, c'est la même chose. Soit A une vidéo, une séquence sonore ou une animation. Supposons que A débute à 10 et joue jusqu'à 15 (quelle que soit l'unité). Si B est défini pour suivre A, alors il débute à 15 (et non à 15 plus un intervalle minimum). Lorsque le moteur d'exécution d'une animation rend effectivement les images (ou les échantillons pour du son) et doit rendre le temps 15, il ne devrait pas montrer à la fois une image de A et une image de B mais seulement le nouvel élément B. De même pour le son, ou pour tout intervalle dans une ligne de temps. Si le modèle n'utilise pas une temporisation à point limite exclu, le moteur dessinera des images qui se chevauchent, ou produira des chevauchements d'échantillons sonores ou d'animations successives, etc.

Remarquez que les transitions de A vers B obéissent également au modèle de temporisation d'intervalles. Elles nécessitent vraiment que A ne se termine pas à 15, et que les deux éléments se chevauchent en réalité. Néanmoins, la durée de A est simplement prolongée de la durée de la transition (par exemple, une seconde). Cette nouvelle durée de A est également à point limite exclu (à la fin de cette nouvelle durée, la transition sera terminée et seul B devrait être rendu) et A n'est plus nécessaire.

Les implications pour l'animation

Pour l'animation, plusieurs conséquences importantes en découlent : la définition de la répétition et la valeur échantillonnée dans l'état figé.

Pour la répétition d'une animation, l'arithmétique suit le modèle à point limite exclu. Soit l'exemple suivant :

<animation dur="4s" repeatCount="4" .../>

Au temps 0, la durée simple est échantillonnée à 0, et la première valeur est appliquée. C'est le début inclusif de l'intervalle. La durée simple est échantillonnée normalement jusqu'à quatre secondes. Toutefois, la bonne façon d'aligner le temps de la durée active sur le temps de la durée simple est d'utiliser le reste (N.d.T. remainder) de la division par la durée simple :

tempsSimple = REMAINDER( activeTime, d )

Ou encore :

F(t) = f( REMAINDER( t, d ) ), où t se trouve dans la durée active.

Remarque : On définit REMAINDER( t, d ) comme t - d*floor(t/d)

D'après cela, un temps de 4 (ou 8, ou 12) correspond au temps de 0 de la durée simple. Le point limite de la durée simple est exclu de (c'est-à-dire, en fait non échantillonné sur) la durée simple.

Il s'ensuit que la dernière valeur d'une fonction d'animation f(t) ne sera peut-être en réalité jamais appliquée (par exemple, pour une interpolation linéaire). Cela sera peut-être vrai dans le cas d'une animation qui ne se répète pas et ne définit pas fill="freeze". Par contre, dans l'exemple suivant, la valeur appropriée pour l'état figé est clairement celle de l'attribut to :

<animation from="0" to="5" dur="4s" fill=freeze .../>

Cela n'enfreint pas le modèle de temporisation d'intervalles mais impose effectivement une qualification supplémentaire de la fonction d'animation f(t) pendant l'état figé :

La définition de l'accumulation s'aligne également sur ce modèle. L'arithmétique est en fait inversée et les valeurs s'accumulent en ajoutant un multiple de la dernière valeur définie de la fonction d'animation f(t).

3.6.3. L'unification de la temporisation interactive et de la temporisation programmée

La spécification SMIL Animation décrit les extensions de SMIL 1.0 pour gérer une temporisation interactive des éléments d'animation. Ces extensions permettent à l'auteur d'indiquer si une animation devrait débuter ou finir en réponse d'un événement (tel qu'un événement d'interface utilisateur comme click), ou de l'activation d'un hyperlien, ou de l'appel d'une méthode DOM.

La syntaxe qui les décrit utilise les spécifications des valeurs d'événement et la valeur d'argument spéciale "indefinite" pour les valeurs des attributs begin et end. Les valeurs d'événement décrivent des événements d'interface utilisateur et d'autres événements. Les appels de méthodes DOM pour débuter ou finir une animation imposent la valeur spéciale "indefinite" sur l'attribut associé. Un hyperlien peut aussi viser un élément d'animation définissant begin="indefinite". L'animation débutera lorsque l'hyperlien sera activé (habituellement par l'utilisateur cliquant le lien). On ne peut pas contrôler directement la fin active d'une animation en utilisant des hyperliens.

Historique

Le modèle actuel représente une évolution des moteurs d'exécution multimédias anciens. Il s'agissait habituellement de programmateurs statiques purs, ou bien de systèmes événementiels purs. Les modèles programmateurs présentent un plan chronologique linéaire intégrant à la fois des médias discrets et des médias continus. Les modèles programmateurs sont bien adaptés pour raconter des histoires mais leur gestion de l'interaction avec l'utilisateur est limitée. Au contraire, les systèmes événementiels modélisent les présentations multimédias comme un graphe d'associations d'événements. Les systèmes événementiels offrent une gestion flexible de l'interaction avec l'utilisateur mais ont généralement des fonctions de planification réduites : ils se destinent plutôt aux présentations multimédias hautement interactives et participatives.

Le modèle SMIL 1.0 est essentiellement un modèle de programmation, avec cependant une certaine flexibilité pour gérer les médias continus de durée inconnue. L'interaction avec l'utilisateur prend la forme d'une sémantique d'hyperliens temporisés, mais l'activation d'éléments individuels via une interaction n'était pas prise en charge.

La modélisation d'un contenu interactif événementiel dans SMIL

Pour intégrer du contenu interactif dans une temporisation SMIL, le modèle programmateur de SMIL 1.0 est étendu afin de gérer plusieurs concepts nouveaux : la temporisation indéterminée et l'activation de l'élément.

Avec la temporisation indéterminée, le temps de début (ou de fin) de l'élément n'est pas défini. L'élément existe toujours dans le cadre des contraintes du document, par contre le temps de début (ou de fin) est déterminé par une activation externe. L'activation peut être le fait d'un événement (tel qu'un événement d'interface utilisateur), d'un hyperlien (un hyperlien visant l'élément) ou du DOM (par exemple, l'appel de la méthode beginElement()). Dans une perspective programmée, le temps est décrit comme non résolu avant l'activation. Dès lors que le début (ou la fin) de l'élément est activé, le temps est résolu.

La gestion de l'activation par événement permet d'associer un événement au début ou au temps de fin active d'un élément. Lorsque l'événement se produit (par exemple, lorsque l'utilisateur clique sur quelque chose), le temps associé est résolu en un temps déterminé. Pour les temps de début événementiels, l'élément devient actif (commence à jouer) dès le moment où l'événement a lieu (plus un décalage défini éventuel). L'élément joue depuis le début de la fonction d'animation. Pour les temps de fin active événementiels, l'élément devient inactif (cesse de jouer) lorsque l'événement associé se produit.

Remarquez qu'une fin événementielle ne s'activera pas tant que l'élément n'a pas déjà commencé. Tout événement de fin défini sera ignoré avant le début de l'élément. Cf. également la section La sensibilité de l'événement.

Remarquez que pour la relance d'un élément, tout temps de fin événementiel résolu dans l'instance de lecture précédente se replacera dans un état non résolu.

L'activation par lien s'apparente à l'activation par événement. La sémantique des hyperliens définie dans SMIL 1.0 consiste à rechercher dans le document un point dans le temps. Combinée à une temporisation indéterminée, l'hyperliaison produit une variante du contenu interactif. Un hyperlien peut viser un élément sans temps de début programmé. L'élément débute lorsque le lien est traversé. Les informations concernant le moment où l'hyperlien active un élément et celui où il accède à la ligne de temps du document se trouvent dans la section suivante.

Remarquez que l'activation de l'hyperlien concerne seulement le temps de début de l'élément et non sa fin. L'activation par événement, ou par le DOM, peut s'appliquer aux temps de début comme à ceux de fin.

Remarquez que les éléments peuvent définir le début ou la fin par rapport à un autre élément, en utilisant une valeur de base de synchronisation (le début ou la fin d'un autre élément). Si l'élément de base de synchronisation est défini à son tour, par exemple, avec des temps événementiels, la valeur de base de synchronisation n'est pas résolue, et le début ou la fin de l'élément courant ne sont donc également pas résolus. Pour que le temps de début (ou de fin) soit résolu, la valeur de base de synchronisation référencée doit l'être aussi.

3.6.4. La sensibilité de l'événement

Cette section est informative

Le modèle de temporisation gère une synchronisation basée sur des événements imprévisibles, tels que les événements DOM ou ceux générés par l'interface utilisateur. Le modèle de manipulation des événements est tel que l'élément de temporisation reçoit la notification de l'événement, et cet élément utilise un ensemble de règles pour résoudre toute synchronisation dépendant de l'événement.

Cette section est normative

La sémantique de la sensibilité des éléments aux événements est décrite par l'ensemble de règles suivant :

  1. Si l'élément n'est pas actif, alors les événements sont manipulés seulement pour les définitions de début. Donc si l'événement se produit et que l'attribut begin définit l'événement, l'élément débute. Tant que l'élément n'est pas actif, toute définition de l'événement de l'attribut end est ignorée ;
  2. Si l'élément est (déjà) actif lorsque l'événement se produit et que l'attribut begin définit l'événement, le comportement dépend alors de la valeur de l'attribut restart :
    1. Si restart="always", alors un nouveau temps de début est résolu pour l'élément d'après le temps de l'événement. Toute définition de l'événement par l'attribut end est ignorée pour cette instance de l'événement 
    2. Si restart="never" ou restart="whenNotActive", alors toute définition de l'événement par l'attribut begin est ignorée pour cette instance de l'événement. Si l'attribut end définit l'événement, alors une valeur de fin est résolue d'après le temps de l'événement, et la durée active est réévaluée (conformément aux règles de la section Le calcul de la durée active).

Il importe de noter qu'en aucun cas une seule occurence d'événement n'est utilisée pour résoudre à la fois un temps de début et un temps de fin sur le même élément.

La sensibilité des événements d'utilisateur et la temporisation

Le modèle de temporisation et le modèle des événements d'utilisateur sont grandement orthogonaux. Quoique le modèle de temporisation référence bien les événements d'utilisateur, il ne définit pas comment ces événements sont générés et, en particulier, il ne définit pas la sémantique du ciblage au clavier, du confinement de la souris, de la cliquabilité et des problèmes apparentés. Parce que la temporisation peut affecter la présentation des éléments, elle peut agir sur les règles de traitement des événements d'utilisateur, toutefois elle a seulement un effet si la présentation de l'élément est affectée.

3.6.5. Les hyperliens et la temporisation

La sémantique d'hyperliaison doit être spécialement définie pour l'animation afin d'assurer un comportement prévisible. Les sémantiques d'hyperliaison précédentes, comme celle définie par SMIL 1.0, sont insuffisantes, car elles ne gèrent pas la temporisation indéterminée ni la temporisation interactive. Nous étendons ici la sémantique de SMIL 1.0 à utiliser dans les présentations comprenant des animations avec une temporisation indéterminée et interactive.

On décrit le comportement d'hyperliaison comme une recherche dans le document. Dans ce sens, rechercher signifie avancer la ligne de temps du document jusqu'au temps défini.

Un hyperlien peut viser un élément d'animation en définissant la valeur de l'attribut id dans la partie fragment du localisateur de lien. La traversée d'un hyperlien appelant une animation se déroulera conformément aux règles suivantes :

  1. Si l'élément cible est actif, rechercher le temps du document en revenant au temps de début (courant) de l'élément. S'il y a plusieurs temps de début, prendre le temps de début correspondant à l'instance de début courante ;
  2. Si le temps de début de l'élément cible est résolu (c'est-à-dire que la liste des temps de début contient un temps résolu, ou si le temps de début a été forcé précédemment par un hyperlien ou un appel de la méthode beginElement()), rechercher le temps du document (au besoin, en avant ou en arrière) jusqu'au temps de début résolu le plus ancien de l'élément cible. Remarquez que le temps de début peut être résolu en conséquence de l'activation précédente d'un hyperlien, du DOM ou d'un événement. Une fois le temps de début résolu, la traversée de l'hyperlien se poursuit toujours ;
  3. Sinon (le temps de début de l'animation n'est pas résolu), résoudre simplement le temps de début de la cible d'animation au temps courant du document. Ne pas tenir compte de la base de synchronisation ou de la base d'événement de l'animation, et ne pas propager à rebours une quelconque logique de temporisation pour résoudre le sous-élément mais le traiter plutôt comme s'il avait été défini avec begin="indefinite", et simplement résoudre le temps de début au temps courant du document.

Remarquer que l'activation de l'hyperlien n'introduit aucun comportement de relance et elle n'est pas soumise à la sémantique de l'attribut restart.

S'il faut rechercher le temps de présentation du document, il sera peut-être nécessaire d'effectuer une recherche en avant, ou bien en arrière, en fonction du temps de début résolu de l'élément et du temps courant au moment de la traversée de l'hyperlien.

Après une recherche en avant dans le document, celui-ci devrait se trouver dans le même état que si l'utilisateur avait laissé la présentation jouer normalement depuis le temps courant jusqu'à atteindre le temps de début de l'élément d'animation (mais sans interagir avec le document par ailleurs). En particulier, la recherche en avant du temps de présentation devrait aussi entraîner le début des autres éléments d'animation ayant des temps de début résolus entre le temps courant et le temps recherché. Ces éléments pourront être terminés, ou être toujours actifs ou figés au temps recherché, selon leurs temps de début et leurs durées actives. Tous les éléments d'animation actifs au moment de l'hyperliaison devraient également aller en avance rapide sur l'intervalle de recherche. Ils peuvent se terminer ou être toujours actifs ou figés au temps recherché, selon leurs durées actives. L'effet net de la recherche en avant d'un temps de présentation place le document dans un état identique à celui du temps recherché comme si la présentation du document était tranquillement parvenue jusque-là.

Si le temps de début résolu de l'élément d'animation cible d'un hyperlien est situé avant le temps de présentation courant, alors la recherche du temps de présentation doit se faire en arrière. La recherche en arrière rebobinera toutes les animations actives dans l'intervalle de recherche et éteindra toutes les animations résolues pour débuter après le temps recherché. Remarquez que les temps de début résolus (par exemple, un début associé à un événement) ne sont pas remis à zéro ou perdus du fait de la recherche d'un temps antérieur. Conformément aux règles précédentes pour les hyperliens visant des éléments d'animation, les hyperliens vers des éléments avec un temp de début résolu fonctionneront normalement, en avançant le temps de présentation au temps résolu précédemment.

Cette sémantique d'hyperliaison suppose qu'un enregistrement des temps de début résolus de tous les éléments d'animation soit tenu, et que cet enregistrement soit disponible pour déterminer le temps de présentation exact à rechercher. Une fois résolus, les temps de début ne sont pas remis à zéro. Par contre, ils peuvent être remplacés au cours des résolutions successives conduites par les occurrences multiples d'un événement (c'est-à-dire au cours d'une relance). Par exemple :

<animate id="A" begin="10s" .../>
<animate id="B" begin="A.begin+5s" .../>
<animate id="C" begin="click" .../>
<animate id="D" begin="C.begin+5s" .../>
...
<a href="#D">Lancer la dernière animation</a>

On peut résoudre immédiatement le temps de début respectif des éléments A et B comme étant 10 et 15 secondes. Les débuts des éléments C et D ne sont pas résolus au début du document. L'activation de l'hyperlien n'aura donc aucun effet sur le temps de présentation ou sur les éléments C et D. Supposons maintenant que C soit cliqué à 25 secondes dans la présentation. Le clic sur C résoud à son tour le début de D à 30 secondes. Dès lors la traversée de l'hyperlien entraînera la recherche du temps de présentation à 30 secondes.

Si à 60 secondes dans la présentation l'utilisateur clique encore une fois sur C, le temps de présentation de D se résoudra à nouveau à 65 secondes. L'activation suivante de l'hyperlien entraînera la recherche du temps de présentation à 65 secondes.

3.6.6. La propagation des changements aux temps

Les temps peuvent changer dans plusieurs cas au cours de la présentation du document. En particulier, si le temps d'une animation est défini relativement à un événement, le temps (c'est-à-dire le début et la fin active de l'animation) est résolu lorsqu'advient l'événement. Un autre cas se présente pour un comportement de répétition : les temps de début et de fin active d'une animation peuvent tous deux changer lorsqu'elle est relancée. Comme on peut définir les temps de début et de fin active d'une animation par rapport aux débuts ou aux fins actives d'autres animations, tous les changements de temps doivent se propager à travers le document.

Si une animation foo a un temps de début (ou de fin active) qui définit un élément de base de synchronisation (par exemple, comme bar ici) :

<rect ...>
   <animate id="bar" end="click" .../>
   <animate id="foo" begin="bar.end" .../>
</rect>

On dit de foo qu'il est un dépendant temporel de bar, à savoir que le temps de début de foo dépend de la fin active de bar.

L'élément A est un dépendant temporel d'un autre élément B, si A définit B comme élément de base de synchronisation. En outre, si l'élément A est un dépendant temporel de l'élément B et que B est un dépendant temporel de l'élément C (c'est-à-dire que B définit C comme élément de base de synchronisation), alors l'élément A est un dépendant temporel indirect de l'élément C.

Lorsqu'un élément débute ou finit, ses dépendants temporels sont effectivement avisés de l'action, et la programmation des dépendants temporels peut en être affectée. Remarquez qu'un élément doit en réalité débuter avant que les dépendants temporels (relatifs au début) ne soient affectés, et se terminer avant que les dépendants temporels (relatifs à la fin) ne le soient. Cela influence la définition de l'ordre de priorité des éléments d'animation, comme expliqué dans la section Le modèle d'animation en sandwich.

Dans l'exemple précédent, tous les changements de fin active de l'élément bar doivent être propagés au début de l'élément foo. L'effet des changements dépend de l'état de foo lorsque les changements ont lieu, comme précisé ci-dessous.

Si le temps de début d'un élément dépend d'un autre élément (comme pour foo dans l'exemple), le comportement résultant lorsque l'élément de base de synchronisation (bar) propage les changements est déterminé comme suit :

Remarquez que la sémantique s'apparente directement à une temporisation événementielle avec l'attribut restart.

Si le temps de fin d'un élément dépend d'un autre élément, la sémantique est beaucoup plus simple :

On peut l'approcher autrement en constatant que le temps de fin est toujours recalculé, mais la présentation n'en sera pas affectée à moins que l'élément ne soit actuellement actif, ou à moins que l'élément ne débute (ou est relancé) après que le changement est advenu.

3.6.7. La grammaire des valeurs d'attributs de temporisation

Cette section est normative

Les définitions de syntaxe utilisent la notation EBNF, comme définie dans [XML10].

Dans les définitions de syntaxe à suivre, les caractères blancs permis sont signalés par un S, et sont définis comme suit (tiré de la définition [XML10] de S) :

S ::= (#x20 | #x9 | #xD | #xA)*
Les valeurs de début

Cette section est normative

Une liste de valeurs de début représente une liste d'indicateurs de temporisation, séparés par des points-virgules :

begin-value-list ::= begin-value (S ";" S begin-value-list )?
begin-value      ::= (offset-value | syncbase-value
                      | event-value
                      | repeat-value | accessKey-value
                      | wallclock-sync-value | "indefinite" )
Les valeurs de fin

Cette section est normative

Une liste de valeurs de fin représente une liste d'indicateurs de temporisation, séparés par des points-virgules :

end-value-list ::= end-value (S ";" S end-value-list )?
end-value      ::= (offset-value | syncbase-value
                      | event-value
                      | repeat-value | accessKey-value
                      | wallclock-sync-value | "indefinite" )
L'analyse des indicateurs de temporisation

Plusieurs valeurs d'indicateurs de temporisation ont une syntaxe similaire. En outre, les attributs id XML peuvent contenir le caractère séparateur point .. Le caractère barre oblique inverse \ peut servir à masquer le séparateur point dans les appels d'identificateurs et de noms d'événement. Pour analyser un élément particulier dans une liste de valeur, l'approche suivante définit la bonne interprétation.

  1. Ôter tous les caractères blancs de tête, de queue, ou intermédiaires ;
  2. Si la valeur commence par un chiffre ou un indicateur de signe numérique (c.à.d., + ou -), alors il faudrait interpréter la valeur comme une valeur de décalage ;
  3. Si la valeur commence par l'atome "wallclock", alors il faudrait la traiter comme une valeur de synchronisation d'horloge (N.d.T. wallclock-sync-value) ;
  4. Si la valeur est l'atome "indefinite", alors il faudrait la traiter comme la valeur "indefinite" ;
  5. Sinon déterminer une sous-chaîne d'atome jusqu'à un éventuel indicateur de signe sans l'inclure (c.à.d. ôter un éventuel décalage). Ensuite, ignorer tout caractère séparateur point . précédé d'un caractère de masquage barre oblique inverse \. En outre, ôter tout caractère de masquage \ en tête.
    1. Si l'atome ne contient aucun caractère séparateur ., alors il faudrait traiter la valeur comme une valeur d'événement (N.d.T. event-value) avec un élément de base d'événement non défini (c.à.d par défaut) ;
    2. Si l'atome se termine par la chaîne ".begin" ou bien ".end", alors il faudrait traiter la valeur comme une valeur de base de synchronisation (N.d.T. syncbase-value) ;
    3. Sinon il faudrait traiter la valeur comme une valeur d'événement (avec un élément de base d'événement défini). Tout caractètre de masquage \ après le caractère séparateur . devrait être supprimé avant d'analyser la valeur d'événement.

Cette approche permet aux mises en œuvre de traiter les atomes "wallclock" et indefinite comme identificateurs d'éléments réservés, et begin, end et marker comme noms d'événements réservés, tout en gardant un mécanisme de masquage pour appeler les éléments et événements ayant ces noms.

Les valeurs d'horloge

Les valeurs d'horloge ont la syntaxe suivante :

Clock-value         ::= ( Full-clock-value | Partial-clock-value 
                          | Timecount-value )
Full-clock-value    ::= Hours ":" Minutes ":" Seconds ("." Fraction)?
Partial-clock-value ::= Minutes ":" Seconds ("." Fraction)?
Timecount-value     ::= Timecount ("." Fraction)? (Metric)?
Metric              ::= "h" | "min" | "s" | "ms"
Hours               ::= DIGIT+; tout nombre positif
Minutes             ::= 2DIGIT; intervalle de 00 à 59
Seconds             ::= 2DIGIT; intervalle de 00 à 59
Fraction            ::= DIGIT+
Timecount           ::= DIGIT+
2DIGIT              ::= DIGIT DIGIT
DIGIT               ::= [0-9]

Pour une valeur de compte de temps, le suffixe métrique par défaut est s (pour secondes). Aucun caractère blanc intermédiaire n'est admis dans les valeurs d'horloge, quoique les caractères blancs de tête et de queue seront ignorés.

Voici des exemples de valeurs d'horloge légales :

Les valeurs fractionnaires sont simplement des définitions de secondes en virgule flottante (base 10). Le nombre de chiffres permis n'est pas limité (quoique la précision réelle puisse varier d'une mise à l'œuvre à l'autre). Par exemple :

00.5s = 500 millisecondes
00:00.005 = 5 millisecondes
Les valeurs de décalage

Les valeurs de décalage servent à définir quand un élément devrait débuter ou finir relativement à sa base de synchronisation.

Cette section est normative

La syntaxe d'une valeur de décalage (N.d.T. offset-value) est la suivante :

offset-value   ::= (( S "+" | "-" S )? ( Clock-value )

La base de synchronisation implicite d'une valeur de décalage est le début du document.

Les valeurs d'appel d'ID

Cette section est normative

Les valeurs d'appel d'ID (N.d.T. ID reference values) sont des références à la valeur de l'attribut "id" d'autres éléments dans le document.

Id-value   ::= IDREF
Les valeurs de base de synchronisation

Une valeur de base de synchronisation (N.d.T. syncbase value) commence par un terme Syncbase-element, définissant la valeur de l'attribut "id" d'un autre élément, appelé élément de base de synchronisation (N.d.T. syncbase element).

Cette section est normative

La syntaxe d'une valeur de base de synchronisation est la suivante :

Syncbase-value   ::= ( Syncbase-element "." Time-symbol ) ( S ("+"|"-") S Clock-value )?
Syncbase-element ::= Id-value
Time-symbol ::= "begin" | "end"

L'élément de base de synchronisation est qualifié par l'un des symboles temporels suivants :

begin
Définit le temps de début de l'élément de base de synchronisation.
end
Définit la fin active de l'élément de base de synchronisation.

Exemples :

begin="x.end-5s"     : débute 5 secondes avant que "x" se termine
begin="x.begin"      : débute quand "x" débute
begin="x.begin + 1m" : finit une minute après que "x" a débuté
Les valeurs d'événement

Cette section est informative

Une valeur d'événement (N.d.T. event-value) commence par un terme Eventbase-element qui définit l'élément de base d'événement (N.d.T. event-base element). L'élément de base d'événement désigne celui sur lequel l'événement est observé. D'après le bouillonnement d'événement DOM, l'élément de base d'événement peut être l'élément qui a produit l'événement, ou bien un élément ancêtre sur lequel on peut observer l'événement qui a bouillonné. Cf. [DOM2Events] pour des précisions.

Cette section est normative

La syntaxe d'une valeur d'événement (N.d.T. event-value) est la suivante :

Event-value       ::= ( Eventbase-element "." )? Event-symbol ( S ("+"|"-") S Clock-value )?
Eventbase-element ::= ID

L'élément de base d'événement doit être un autre élément contenu dans le document hôte.

Si le terme Eventbase-element est absent, l'élément de base d'événement est défini comme l'élément cible d'animation.

La valeur d'événement doit indiquer un terme Event-symbol. Ce terme indique le nom de l'événement produit sur l'élément de base d'événement. Le développeur du langage hôte doit indiquer quels sont les événements pouvant être définis.

Le dernier terme indique une valeur de décalage optionnelle représentant un décalage depuis le temps de l'événement.

Cette section est informative

Ce module définit plusieurs événements pouvant entrer dans l'ensemble reconnu par le langage hôte, dont les événements beginEvent et endEvent. On ne devrait pas les confondre avec les valeurs de temps de la base de synchronisation. Cf. la section Les événements et le modèle d'événement.

La sémantique de la temporisation par événements est abordée dans la section L'unification de la temporisation interactive et de la temporisation programmée.

Exemples :

begin=" x.load "        : débute lorsque "load" est observé sur "x"
begin="x.focus+3s"      : débute 3 secondes après un "focus" sur "x"
begin="x.endEvent+1.5s" : débute 1 seconde et demie après un "endEvent" sur "x"
begin="x.repeat"        : débute à chaque fois qu'un "repeat" est observé sur "x"
Les valeurs de répétition

Les valeurs de répétition constituent des variantes sur les valeurs d'événement reconnaissant un événement de répétition qualifié. L'événement repeat défini dans la section Les événements et le modèle d'événement admet un suffixe supplémentaire pour qualifier l'événement avec une valeur d'itération.

La syntaxe d'une valeur de répétition (N.d.T. repeat-value) est la suivante :

Repeat-value       ::= ( Eventbase-element "." )? "repeat(" iteration ")"
                       ( S ("+"|"-") S Clock-value )? 
iteration          ::= DIGIT+

Si cette forme qualifiée est utilisée, la valeur de base d'événement sera seulement résolue lorsque sera observé un événement repeat dont la valeur d'itération correspond à l'itération indiquée.

La syntaxe de l'événement de répétition qualifié permet seulement à l'auteur de répondre à une répétition particulière de l'élément.

L'exemple suivant décrit une valeur de base d'événement de répétition qualifiée :

<animate id="foo" repeatCount="10" end="endAnim.click" ... />
<img id="endAnim" begin="foo.repeat(2)" .../>

L'image endAnim apparaîtra à la deuxième répétition de l'élément animate foo. Cet exemple permet à l'utilisateur d'arrêter l'animation après qu'elle a joué au moins deux fois.

Les valeurs de touche d'accès

Les valeurs de touche d'accès permettent à l'auteur d'associer un temps de début ou de fin à la pression d'une touche particulière, indépendamment des questions de focalisation. Ce mécanisme est inspiré du traitement des touches d'accès de HTML. À la différence de HTML, les agents utilisateurs ne devraient pas imposer de touche de modification (telle que la touche ALT) pour obligatoirement actionner une touche d'accès.

La syntaxe d'une valeur de touche d'accès (N.d.T. accesskey-value) est la suivante :

AccessKey-value  ::= "accessKey(" character ")"
                      ( S ("+"|"-") S Clock-value )?

Le terme character représente un caractère seul provenant du jeu de caractères [ISO10646].

La valeur de temps est définie comme le moment où l'utilisateur saisit le caractère.

Les valeurs de synchronisation d'horloge

Cette section est informative

La syntaxe des valeurs de synchronisation d'horloge (N.d.T. wallclock-val] est la suivante. Les valeurs permises sont fondées sur plusieurs profils décrits dans [DATETIME], fondé à son tour sur [ISO8601].

Cette section est normative

wallclock-val  ::= "wallclock(" S (DateTime | WallTime)  S ")"
DateTime       ::= Date "T" WallTime
Date           ::= Years "-" Months "-" Days
WallTime       ::= (HHMM-Time | HHMMSS-Time)(TZD)?
HHMM-Time      ::= Hours24 ":" Minutes
HHMMSS-Time    ::= Hours24 ":" Minutes ":" Seconds ("." Fraction)?
Years          ::= 4DIGIT;
Months         ::= 2DIGIT; intervalle de 01 à 12
Days           ::= 2DIGIT; intervalle de 01 à 31
Hours24        ::= 2DIGIT; intervalle de 00 à 23
4DIGIT         ::= DIGIT DIGIT DIGIT DIGIT
TZD            ::= "Z" | (("+" | "-") Hours24 ":" Minutes )

Cette section est informative

Date complète avec heures et minutes :

   YYYY-MM-DDThh:mmTZD (par exemple, 1997-07-16T19:20+01:00)

Date complète avec heures, minutes et secondes :

   YYYY-MM-DDThh:mm:ssTZD (par exemple, 1997-07-16T19:20:30+01:00)

Date complète avec heures, minutes, secondes et fraction décimale de seconde :

   YYYY-MM-DDThh:mm:ss.sTZD (par exemple, 1997-07-16T19:20:30.45+01:00)

Remarquez que la syntaxe des termes Minutes, Seconds, Fraction, 2DIGIT et DIGIT est définie comme celle du type Clock-values. Remarquez que les caractères blancs ne sont pas admis dans la définition de date et heure.

Cette section est normative

Il y a trois façons de traiter les décalages horaires :

  1. Les temps s'expriment en temps UTC (temps universel coordonné) avec un indicateur UTC spécial (Z) ;
  2. Les temps s'expriment en temps local avec un décalage horaire en heures et minutes. Un décalage horaire de +hh:mm indique une date/heure dans un temps local en avance de hh heures et mm minutes sur le temps UTC. Un décalage horaire de -hh:mm indique une date/heure dans un temps local en retard de hh heures et mm minutes sur le temps UTC ;
  3. Les temps s'expriment dans le temps local défini au lieu où la présentation est exécutée. Le fuseau horaire local de la plate-forme de l'utilisateur final est utilisé.

Le moteur de présentation doit être capable de convertir des valeurs d'horloge dans un temps du document.

Cette section est informative

Remarquez que le temps de début (ou de fin) résultant peut être antérieur au début (ou postérieur à la fin) du conteneur de temps parent. Cela ne constitue pas une erreur, et les contraintes du conteneur de temps s'appliquent toujours. Dans tous les cas, la sémantique des attributs begin et end régit l'interprétation de la valeur d'horloge.

3.6.8. L'évaluation des listes de temps de début et de fin

Cette section est informative

Les éléments d'animation peuvent avoir plusieurs valeurs de début et de fin. Il nous faut définir la sémantique associée à des temps de début et de fin multiples, et comment fonctionne un modèle de graphe temporel dynamique avec ces valeurs multiples.

Le modèle s'articule autour de la notion d'intervalle de chaque élément. Un intervalle est définit par un temps de début et un temps de fin. Au fur et à mesure de l'exécution du graphe temporel, plusieurs intervalles peuvent être créés pour un élément avec des temps de début et de fin multiples. À tout moment donné, un seul intervalle courant est associé à chaque élément. Les intervalles sont créés en évaluant une liste de temps de début et une liste de temps de fin, chacune étant fondée sur les conditions décrites par les attributs begin et end de l'élément.

Les listes des temps de début et des temps de fin servant à calculer les nouveaux intervalles sont appelées des listes de temps d'instance. Chaque temps d'instance dans l'une des listes est associé à la définition d'une condition de début ou de fin, définie dans la syntaxe de l'attribut. Certaines conditions comme les valeurs de décalage n'ont qu'une seule instance dans la liste. D'autres conditions peuvent en avoir plusieurs si la condition peut apparaître plusieurs fois. Par exemple, une valeur de base de synchronisation peut avoir plusieurs temps d'instance si l'élément de base de synchronisation a exécuté plusieurs intervalles, tout comme une valeur d'événement si l'événement s'est produit plusieurs fois.

Les listes des temps d'instance de chaque élément sont initialisées à l'initialisation du graphe temporel, et elles existent pour toute la durée de vie du graphe temporel. Dans cette version du modèle temporel sans conteneur de temps, les temps d'instance restent indéfiniment dans les listes dès qu'ils y ont été ajoutés. Par exemple, les temps associés aux valeurs d'événements sont seulement ajoutés lorsque l'événement en question se produit, mais ils restent ensuite dans les listes. De même, les temps d'instance des valeurs de base de synchronisation s'ajoutent à la liste à chaque création d'un nouvel intervalle pour l'élément de base de synchronisation, et ils restent dans la liste.

À l'initialisation du graphe temporel, chaque élément crée un premier intervalle courant. Le temps de début sera en général résolu, mais le temps de fin souvent ne le sera pas. Si l'élément peut être relancé tant qu'il est actif, l'intervalle courant pourra être terminé (précocement) au prochain temps de début. Cet intervalle sera exécuté puis, une fois terminé, l'élément passera en revue les listes de temps d'instance de début et de fin. S'il fallait exécuter l'élément à nouveau, un autre intervalle serait créé, et le nouvel intervalle deviendrait l'intervalle courant. On peut assimiler l'histoire d'un élément à un ensemble d'intervalles.

Puisque les temps de début et de fin peuvent dépendre d'autres temps susceptibles de changer, l'intervalle courant peut changer au cours du temps. Par exemple, si l'un des temps d'instance de fin change pendant l'exécution de l'intervalle courant, la fin de l'intervalle courant sera recalculée et pourra changer. Néanmoins, une fois que le temps est échu, il est fixé. C'est-à-dire que si l'intervalle courant est débuté, son temps de début ne peut plus changer, et s'il est terminé son temps de fin non plus. Pour que l'élément puisse être relancé, il doit terminer l'intervalle courant puis en créer un nouveau pour effectuer la relance.

Si une condition de début (ou de fin) définit une dépendance temporelle vis-à-vis d'un autre élément (par exemple, avec une valeur de base de synchronisation), la dépendance temporelle est généralement assimilée à une relation entre les deux éléments. Ce niveau de dépendance est important pour le modèle lorsqu'un élément crée un nouvel intervalle courant. Par contre, pour la propagation des changements aux temps individuels, les dépendances temporelles constituent plus spécifiquement la dépendance d'un intervalle donné de l'élément de base de synchronisation à un temps d'instance particulier dans l'une des listes de temps d'instance de l'élément dépendant. Puisque seuls les temps de début et de fin de l'intervalle courant peuvent changer, seul l'intervalle courant générera les avis de changement de temps et les propagera aux temps d'instance du dépendant.

Dans cette section, lorsqu'on cite les temps de début et de fin d'un élément, ces temps sont décrits dans le temps du document (relatifs au début du document). Tous les arcs de synchronisation (N.d.T. sync-arcs), tous les arcs d'événements (N.d.T. event arcs), toutes les valeurs d'horloge, etc. doivent être convertis dans cet espace temporel pour faciliter la comparaison.

Les boucles dans le graphe temporel doivent être détectées et interrompues pour assurer le fonctionnement raisonnable de la mise en œuvre. On décrit un modèle pour y parvenir dans le cas général. Le modèle ne définit pas de mécanisme pour traiter certaines dépendances cycliques utiles.

Le reste de cette section présente la sémantique des listes de temps d'instance, le cycle de vie de l'élément et les mécanismes pour manipuler les relations et cycles de dépendance.

Les listes de temps d'instance

Les listes d'instances sont associées à chaque élément et existent pour la durée du document (c'est-à-dire qu'il n'y a aucun cycle de vie pour les listes d'instances). Les listes d'instances peuvent changer, et on peut ajouter ou supprimer certains temps, par contre les listes des temps d'instance de début et de fin persistent.

Chaque élément peut avoir un attribut begin définissant une ou plusieurs conditions susceptibles de débuter l'élément. En outre, le modèle de temporisation décrit un ensemble de règles afin de déterminer la fin de l'élément, y compris les effets d'un attribut end avec plusieurs conditions. Pour calculer les temps à utiliser dans un intervalle donné de l'élément, nous devons convertir les temps de début et les temps de fin dans le temps simple du parent puis trier (indépendamment) chaque liste de temps et enfin trouver un couple de temps approprié pour définir l'intervalle.

Les temps d'instance peuvent être résolus ou non. Dans le cas de la liste des temps de fin, la valeur supplémentaire spéciale "indefinite" est admise. Les listes sont tenues en ordre, avec la valeur "indefinite" rangée après tous les autres temps résolus et les temps non résolus rangés à la fin.

Pour le début, la liste s'interprète directement, car les temps de début se fondent seulement sur les conditions dans l'attribut, ou sur la valeur de début par défaut si l'attribut est absent. Toutefois, si la condition de début est une valeur de base de synchronisation, l'élément de base de synchronisation aura peut-être plusieurs intervalles, et il faudra en tenir compte dans la liste des temps de début associée aux conditions.

Pour la fin, la situation est quelque peu complexe, car les conditions de fin représentent seulement une partie du calcul de la fin de durée active. La liste des temps d'instance de fin est utilisée conjointement à d'autres sémantiques de temporisation SMIL pour calculer le temps de fin réel de l'intervalle.

Si un temps d'instance a été défini comme valeurs de base de synchronisation, le temps d'instance conservera une relation de dépendance temporelle avec l'intervalle associé de l'élément de base de synchronisation. C'est-à-dire que si le temps de début (ou de fin) associé de l'intervalle courant de base de synchronisation change, alors le temps d'instance dépendant de cet élément changera aussi.

Lorsqu'un élément crée un nouvel intervalle, il en avise les dépendants temporels et fournit les temps de début et de fin calculés conformément à la sémantique décrite dans la section Le calcul de la durée active. Chaque élément dépendant créera un nouveau temps d'instance lié (c.à.d. établissant une relation de dépendance) au nouvel intervalle de base de synchronisation courant.

La constructions des listes de temps d'instance

La traduction des conditions de début ou de fin en temps d'instance dépend du type de condition :

Si aucun attribut n'est présent, la valeur de début par défaut (une valeur de décalage de "0") devra être évaluée.

Si le début ou la fin de l'élément est déterminé par l'appel d'une méthode DOM (beginElement(), beginElementAt(), endElement() ou endElementAt()), chaque appel de méthode crée un seul temps d'instance (dans la liste de temps d'instance concernée). Ces temps d'instance sont supprimés à la réinitialisation tout comme pour les temps d'événement. Cf. la section La réinitialisation de l'état de l'élément.

Lorsqu'un nouveau temps d'instance est ajouté à la liste des débuts, l'intervalle courant évaluera la sémantique de relance et pourra ignorer le nouveau temps, ou terminer l'intervalle courant (ceci est expliqué dans la section L'interaction avec une sémantique de relance). Par contraste, si un temps d'instance change dans la liste des débuts suite au déplacement du temps de base de synchronisation (de l'intervalle courant), la sémantique de relance n'est pas invoquée mais le temps de début courant peut changer. Si l'intervalle courant n'a pas encore débuté, le changement d'un temps d'instance dans la liste des débuts provoquera une réévaluation des listes d'instances de début, qui peut entraîner le changement du temps de début de l'intervalle. Si le temps de début de l'intervalle change, un avis de changement de temps doit être propagé à tous les dépendants, et la fin de l'intervalle courant doit également être réévaluée.

Lorsqu'un nouveau temps d'instance est ajouté à la liste des fins, ou lorsqu'un temps d'instance change dans la liste des fins, l'intervalle courant réévaluera son temps de fin. S'il change, l'intervalle doit en aviser les dépendants.

Si l'élément a déjà éxécuté tous les intervalles, il n'existera peut-être pas d'intervalle courant. Auquel cas, les ajouts dans l'une ou l'autre liste de temps d'instance, ainsi que les changements de temps d'instance dans l'une ou l'autre liste, conduisent l'élément à réévaluer les listes tout comme il l'aurait fait à la fin de chaque intervalle (comme décrit dans la section La fin d'un intervalle à suivre). Ceci peut entraîner ou non la création d'un nouvel intervalle pour l'élément.

Lorsque des temps sont ajoutés aux listes de temps d'instance, ils peuvent être résolus ou non. S'ils le sont, ils seront convertis dans le temps du document. Si un temps d'instance change de non résolu à résolu, il sera converti de la même façon.

Il existe une différence entre un temps d'instance non résolu et une condition de début (ou de fin) sans instance associée. Si, par exemple, une condition de valeur d'événement est définie dans l'attribut end et qu'aucun événement de ce type ne s'est produit, il n'y aura pas de temps d'instance associé dans la liste des fins. Par contre, si une condition de valeur de base de synchronisation est définie pour l'attribut end et que l'élément de base de synchronisation a un intervalle courant, il y aura un temps d'instance associé dans la liste des fins. Puisque la condition de valeur de base de synchronisation peut être relative à la fin de l'élément de base de synchronisation et que la fin de l'intervalle courant de base de synchronisation ne sera peut-être pas résolue, le temps d'instance associé dans la liste des fins ne sera peut-être pas résolu. Une fois que l'intervalle courant de base de synchronisation est réellement terminé, le temps d'instance dépendant dans la liste des fins recevra un avis de changement de temps de la fin de l'intervalle de base de synchronisation résolue. Le temps d'instance dépendant convertira le temps de base de synchronisation nouvellement résolu en un temps résolu dans le temps du document. Si les listes d'instances ne contenaient pas les temps d'instance non résolus, il faudrait définir un mécanisme supplémentaire pour ajouter le temps d'instance de fin lorsque l'intervalle courant de l'élément de base de synchronisation s'est en fait terminé et a résolu son temps de fin.

La liste des temps résolus comprend des temps historiques définis relativement aux éléments de base de synchronisation, et elle peut donc s'accroître au fur et à mesure si la base de synchronisation a beaucoup d'intervalles. Les mises en œuvre peuvent en optimisation filtrer la liste des temps tant que la sémantique définie ici est respectée.

Le cycle de vie de l'élément

Le cycle de vie d'un élément peut se résumer aux stades principaux suivants :

  1. Le lancement — obtention du premier intervalle
  2. L'attente pour débuter l'intervalle courant
  3. Le temps actif — exécution de l'intervalle
  4. La fin de l'intervalle — calcul du suivant et notification des dépendants
  5. L'après-activité — remplissage éventuel et attente éventuelle de l'intervalle suivant

Les stades 2 à 5 peuvent boucler sur autant d'intervalles que définis avant la fin de la durée simple du parent. Le temps de début de l'intervalle courant peut changer à tout moment au stade 2, et le temps de fin de l'intervalle courant à tout moment aux stades 2 ou 3. Lorsque l'un ou l'autre se produisent, les changements sont répercutés aux dépendants temporels.

À l'initialisation du document et du graphe temporel associé, les listes d'instances sont vides. Comme partie de l'initialisation, les valeurs de décalage simples et la valeur "indefinite" d'un attribut end peuvent être ajoutées dans les listes respectives.

Lorsqu'un élément a exécuté toutes les instances autorisées, on peut le considérer comme bloqué au stade 5. Toutefois tous changements aux listes d'instance au cours de cette période ramèneront l'élément en arrière au stade 4 et entraîneront la création d'un nouvel intervalle courant.

Le lancement — obtention du premier intervalle

Le cycle de vie d'un élément commence avec le début du document. Le cycle démarre par le calcul du premier intervalle courant. Cela nécessite un examen particulier des listes de temps, mais c'est relativement simple. Il ressemble mais n'est pas pareil à l'action entreprise lorsque l'élément se termine (décrit dans la section La fin d'un intervalle). L'idée de base est de trouver le premier intervalle de l'élément et d'en faire l'intervalle courant. Cependant, le modèle devrait traiter deux cas particuliers :

  1. L'élément peut débuter avant le document, et sembler donc débuter au milieu de la ligne de temps locale. Le modèle doit gérer les temps de début situés avant le début du document (c.à.d. avant "0") ;
  2. L'élément possède un ou plusieurs intervalles définis qui débutent et se terminent avant que le document ne débute (avant "0"). Ces intervalles sont éliminés du modèle.

Ainsi, la définition stricte du premier intervalle acceptable de l'élément est le premier à se terminer après le début du document. Voici un pseudo-code pour déterminer le premier intervalle d'un élément. Il suppose un type abstrait Time gérant une fonction de comparaison. Il peut s'agir d'une valeur numérique résolue, de la valeur spéciale INDEFINITE (seulement utilisée avec l'attribut end) et de la valeur spéciale UNRESOLVED. La valeur INDEFINITE est évaluée comme supérieure à toutes les valeurs résolues, et la valeur UNRESOLVED comme supérieure aux valeurs résolues et à INDEFINITE. Le code utilise les listes de temps d'instance associées aux attributs begin et end, comme décrit dans la section précédente.

// Fonction utilitaire qui renvoie "true" si la définition de l'attribut end
// contient des conditions décrivant des valeurs d'événement,
// des valeurs de répétition ou des valeurs de touche d'accès.
boolean endHasEventConditions();
// Calcule le premier intervalle acceptable d'un élément.
// Retourne :
//    un intervalle s'il en existe un
//    FAILURE s'il n'existe aucun intervalle de ce type
Interval getFirstInterval()
{
Time beginAfter=-INFINITY;

while( TRUE ) // boucle jusqu'à return
{
   Set tempBegin = la première valeur dans la liste des débuts >= beginAfter.
   Si cette valeur n'existe pas  // aucun intervalle
      return FAILURE;

   Si aucun attribut end défini
      // Calcul de la fin active sans contraintes de fin
      tempEnd = calcActiveEnd( tempBegin );
   else
   {
      // On a une valeur de début - trouver une fin
      Set tempEnd = la première valeur dans la liste des fins >= tempBegin.
      // Permettre un intervalle de durée non nulle commençant immédiatement
      // après un intervalle de durée nulle.
      Si tempEnd == tempBegin && tempEnd a déjà été utilisé 
        dans un intervalle calculé au cours de cet appel de méthode
      {
         Set tempEnd sur la valeur suivante de la liste end > tempEnd
      }         
      Si cette valeur n'existe pas
      {
         // Les événements laissent la fin en suspens. S'il y a d'autres conditions
         // n'ayant pas encore généré d'instances, elles doivent être 'unresolved'.
         if endHasEventConditions()
            OR si la liste d'instances est vide
            tempEnd = UNRESOLVED;
         // Si toutes les fins se trouvent avant le début, intervalle erroné
         else
            return FAILURE;
      }
      // Calcul de la durée active avec une contrainte de fin
      tempEnd = calcActiveEnd( tempBegin, tempEnd );
   }

   // Nous avons une fin - est-elle après le début simple du parent ?
   if( tempEnd > 0 )
      return( Intervalle( tempBegin, tempEnd ) );

   // L'intervalle est trop tôt
   else if( restart == never )
      // Si on ne peut pas le relancer, intervalle erroné
      return FAILURE;

   else
      // Changer beginAfter pour trouver l'intervalle suivant et boucler
      beginAfter = tempEnd;

} // Fermer la boucle while

} // Fermer getFirstInterval

Remarquez qu'il serait superflu d'examiner le cas de restart="always" avec celui de restart="whenNotActive", puisque nous devons trouver un intervalle qui débute après tempEnd.

Si le modèle ne produit aucun premier intervalle pour l'élément, alors il ne débutera jamais, et il n'y a donc rien de plus à faire à ce point. Par contre, s'il existe un intervalle valide, l'élément doit aviser tous les dépendants temporels de l'existence d'un nouvel intervalle de l'élément. C'est un avis de cet élément à tous les autres éléments qui sont des dépendants temporels directs. C'est différent de la propagation d'un temps qui a changé.

Lorsqu'un élément dépendant reçoit un avis de nouvel intervalle, il inclut une référence au nouvel intervalle. Le nouvel intervalle aura généralement un temps de début résolu et il pourra avoir un temps de fin résolu. Un temps d'instance associé sera ajouté à la liste de temps d'instance de début (ou de fin) de l'élément dépendant, et ce nouveau temps d'instance conservera une relation de dépendance temporelle avec l'intervalle de base de synchronisation.

L'attente pour débuter l'intervalle courant

Cette période n'existe que si l'intervalle courant ne débute pas immédiatement au moment de (ou avant) sa création. Tandis que l'intervalle attend pour débuter, tous les changements de temps de l'intervalle courant de l'élément de base de synchronisation sont répercutés sur les listes d'instances, ce qui peut entraîner un changement de l'intervalle courant.

Si l'élément reçoit un avis de nouvel intervalle pendant qu'il attend de débuter, il ajoutera le temps associé (c'est-à-dire le temps de début ou de fin de l'intervalle de base de synchronisation) à la liste de temps résolus concernée.

Lorsqu'un temps d'instance change, ou lorsqu'un nouveau temps d'instance est ajouté à l'une des listes, l'élément réévalue le temps de début ou de fin de l'intervalle courant (en utilisant l'algorithme décrit dans la section précédente). Si cette réévaluation produit un intervalle changé, un (ou plusieurs) avis de changement de temps seront envoyés aux dépendants concernés.

Il est possible qu'au cours de cette étape les temps de début et de fin puissent changer de telle sorte que l'intervalle ne débute jamais (c'est-à-dire que la fin de l'intervalle se trouve avant son début). Auquel cas, l'intervalle doit être supprimé ainsi que tous les temps d'instance dépendants dans les listes d'instances respectives des éléments dépendants. Ces changements des listes d'instances amèneront une réévaluation des intervalles courants des éléments dépendants, de la même façon que pour un temps d'instance changé.

Le temps actif — exécution de l'intervalle

Cette période a lieu lorsque l'intervalle courant est actif (c'est-à-dire, dès qu'il a débuté et jusqu'à ce qu'il ait fini). Pendant cette période, le temps de fin de l'intervalle peut changer mais pas le temps de début. Si un temps d'instance dans la liste des débuts change après que l'intervalle courant a débuté, ce changement ne l'affectera pas. Ce cas diffère de l'ajout d'un nouveau temps d'instance à la liste des débuts, qui peut entraîner une relance.

Si l'élément reçoit un avis de nouvel intervalle tandis qu'il est actif, il ajoutera le temps associé (c'est-à-dire le temps de début ou de fin de l'intervalle de base de synchronisation) à la liste de temps résolus concernée. Si le nouvel intervalle ajoute un temps à liste des débuts, une sémantique de relance est entreprise, laquelle peut terminer l'intervalle courant.

Si l'attribut restart vaut "always", alors l'intervalle courant se terminera précocement s'il existe un temps d'instance dans la liste des débuts situé avant (c.à.d. plus tôt que) la fin définie de l'intervalle courant. Terminer de cette façon enverra également à tous les dépendants temporels un avis de temps changé de fin de l'intervalle courant. Cf. également la section L'interaction avec une sémantique de relance.

La fin de l'intervalle — calcul du suivant et notification des dépendants

Lorsqu'un élément termine l'intervalle courant, il doit réexaminer les listes des temps résolus de début et de fin. Si un autre intervalle légal est défini pour débuter au temps de fin achevé ou juste après, un nouvel intervalle sera créé. Lorsqu'un nouvel intervalle est créé, il devient l'intervalle courant, et un avis de nouvel intervalle est envoyé à tous les dépendants temporels.

L'algorithme utilisé est très semblable à celui du stade 1, sauf qu'il faut trouver un intervalle débutant après la fin la plus récente.

// Calcule le prochain intervalle acceptable d'un élément
// Retourne
//    un intervalle s'il en existe
//    FAILURE s'il n'en existe pas
Interval getNextInterval()
{
// Remarquez qu'à ce point l'intervalle juste terminé
// est toujours l'intervalle courant
Time beginAfter=currentInterval.end;

   Set tempBegin = la première valeur dans la liste des débuts >= beginAfter.
   Si cette valeur n'existe pas  // aucun intervalle
      return FAILURE;

   Si aucun attribut end n'était défini
      // Calcul de la fin active sans contrainte de fin
      tempEnd = calcActiveEnd( tempBegin );
   else
   {
      // Nous avons une valeur de début - trouver une fin
      Set tempEnd = la première valeur dans la liste des fins >= tempBegin.
      // Permettre un intervalle de durée non nulle commençant immédiatement
      // après un intervalle de durée nulle.
      Si tempEnd == currentInterval.end
      {
         Set tempEnd sur la valeur suivante de la liste des fins > tempEnd
      }         
      Si cette valeur n'existe pas
      {
         // Les événements laissent la fin en suspens. S'il y a d'autres conditions
         // n'ayant pas encore généré d'instances, elles doivent être 'unresolved'.
         if endHasEventConditions()
            OR si la liste d'instances est vide
            tempEnd = UNRESOLVED;
         // Si toutes les fins sont avant le début, intervalle erroné
         else
            return FAILURE;
      }
      // Calcul de la durée active avec une contrainte de fin
      tempEnd = calcActiveEnd( tempBegin, tempEnd );
   }

   return( Intervalle( tempBegin, tempEnd ) );

} // Fermer getNextInterval
L'après-activité — remplissage éventuel et attente éventuelle de l'intervalle suivant

Cette période peut s'étendre depuis la fin d'un intervalle jusqu'au début de l'intervalle suivant, ou jusqu'à la fin de la durée du document (au premier qui advient). Pendant cette période, un éventuel comportement de remplissage est appliqué à l'élément. Les temps de cet intervalle ne peuvent plus changer. Les mises en œuvre peuvent en optimisation opter pour une rupture des relations de dépendance temporelle, puisqu'elles ne produiront plus de changements.

L'interaction avec une sémantique de relance

On doit adopter une sémantique de relance dans deux cas :

  1. Pendant l'exécution de l'intervalle courant, si restart="always", alors toute instance de temps (appelons-la T) dans la liste des débuts située après (c'est-à-dire plus tard que) le début de l'intervalle courant, mais plus tôt que la fin de l'intervalle courant, provoquera la terminaison de l'intervalle courant au temps T. C'est la première étape pour la relance de l'élément : lorsque l'intervalle courant se termine, où l'éventuel intervalle suivant est créé à son tour ;
  2. Lorsqu'un nouveau temps d'instance est ajouté à la liste des débuts des temps d'instance, où les règles de relance peuvent s'appliquer. Les nouveaux temps d'instance peuvent résulter d'une condition de début qui définit l'une des conditions de valeur de base de synchronisation, pour laquelle un avis de nouvelle instance est reçu. Cela peut aussi résulter d'une condition de début qui définit l'une des conditions de valeur d'événement, pour laquelle l'événement associé se produit.
    Dans l'un ou l'autre cas, le paramétrage de l'attribut restart et l'état de l'intervalle courant déterminent le comportement résultant. Le nouveau temps d'instance est calculé (par exemple, d'après le temps de l'intervalle courant de la base de synchronisation, ou d'après le temps de l'événement, y compris un décalage éventuel) puis ajouté à la liste des débuts. Ensuite :
Les dépendances cycliques dans le graphe temporel

Une temporisation SMIL peut créer deux types de cycles : les cycles fermés et les cycles ouverts (ou cycles de propagation). Un cycle fermé apparaît lorsqu'un ensemble d'éléments contient des conditions temporelles mutuellement dépendantes, et qu'aucune autre condition sur les éléments concernés ne peut affecter ou changer cette relation de dépendance, comme dans les exemples 1 et 2 à suivre. Un cycle ouvert (ou cycle de propagation) apparaît lorsqu'un ensemble d'éléments contient des conditions temporelles mutuellement dépendantes, mais que plusieurs conditions sont résolues dans au moins l'une des conditions impliquées. Si un élément quelconque dans le cycle peut générer plusieurs intervalles, le cycle peut se propager. Dans certains cas, cela peut se révéler très utile, comme illustré par l'exemple 3.

Les temps définis dans un cycle fermé ne sont pas résolus, à moins qu'un mécanisme externe ne résolve l'une des valeurs de temps de l'élément (par exemple, l'appel d'une méthode DOM, ou la traversée d'un lien visant l'un des éléments). Si ça se produit, le temps résolu se propagera à travers le cycle, en résolvant toutes les valeurs de temps associées.

Les cycles fermés constituent des conditions d'erreur susceptibles d'entraîner la défaillance du document entier. Dans certaines mises en œuvre, les éléments dans le cycle ne pourront pas débuter ou se terminer correctement. Les exemples 1 et 2 décrivent le comportement le plus indulgent, toutefois les mises en œuvre peuvent simplement rejeter un document avec un cycle fermé.

La détection des cycles

Les mises en œuvre peuvent détecter les cycles dans le graphe temporel en utilisant un drapeau visité sur chaque élément dans le traitement de propagation des changements aux dépendants temporels. À la propagation de l'avis de temps changé, chaque élément dépendant est marqué comme visité. Si le changement sur un temps d'instance dépendant entraîne un changement sur l'intervalle courant de cet élément, ce changement se propagera à son tour à ses dépendants. Ce deuxième avis chaîné se produit dans le contexte du premier avis de temps changé qui l'a causé. L'effet est comme celui d'une pile formée au fur et à mesure de la propagation des changements à travers le graphe, puis défaite après que tous les changements se sont propagés. S'il existe un cycle de dépendance, le chemin de propagation traversera un élément deux fois au cours d'une chaîne de propagation donnée. Cette technique est couramment utilisée pour les traversées de graphes.

On peut adopter une approche similaire pour la construction des chaînes de dépendance au cours de l'initialisation du graphe temporel, et pour la propagation des avis de nouvel intervalle — les mises en œuvre particulières varieront sur ce thème.

Lorsqu'un cycle est détecté, la propagation du changement est ignoré. L'élément qui a détecté la seconde visite ignore le deuxième avis de changement, et rompt donc le cycle.

Exemples

Exemple 1 : Dans l'exemple suivant, les deux animations définissent des temps de début mutuellement dépendants. Il n'existe aucun moyen de les résoudre, et les animations ne débuteront donc jamais

<animate id="foo" begin="bar.begin" .../>
<animate id="bar" begin="foo.begin" .../>

Exemple 2 : Dans l'exemple suivant, les trois animations définissent un cycle moins évident de temps de début et de fin mutuellement dépendants. Il n'y aucun moyen de les résoudre. L'animation joe débutera mais ne finira jamais, et les animations foo et bar ne débuteront jamais.

<animate id="foo" begin="joe.end" .../>
<animate id="bar" begin="foo.begin" dur="3s" .../>
<animate id="joe" begin="0" end="bar.end" .../>

Exemple 3 : Dans l'exemple suivant, les deux animations définissent des temps de début mutuellement dépendants, toutefois la première contient plusieurs conditions de début permettant au cycle de se propager en avant. L'animation foo sera d'abord active de "0" à "3" secondes, avec la deuxième animation bar active de "2" à "5" secondes. Au fur et à mesure de la création de chaque nouvel intervalle courant de foo et bar, elles ajouteront un nouveau temps d'instance dans la liste des débuts de l'autre élément, et le cycle se poursuivra donc en avant. Ces types de cycles ne sont pas interdits car ce comportement de chevauchement en ping-pong n'est pas facile à créer autrement. Et qui plus est, le comportement exact tombera hors du cadre du modèle décrit précédemment

<animate id="foo" begin="0; bar.begin+2s" dur="3s" .../>
<animate id="bar" begin="foo.begin+2s" dur="3s" .../>

Exemple 4 : Dans l'exemple suivant, on décrit un cycle ouvert qui se propage en arrière. Le comportement prévu ne tombera pas hors du cadre du modèle, et il n'est pas géré.

<par dur="10s" repeatCount="11" >
   <video id="foo" begin="0; bar.begin-1s" dur="10s" .../>
   <video id="bar" begin="foo.begin-1s" dur="10s" .../>
</par>

3.7. Le détail des valeurs de la fonction d'animation

Les valeurs de la fonction d'animation doivent être des valeurs légales pour l'attribut défini. Trois classes de valeurs sont décrites :

  1. Les valeurs scalaires sans unité. Ce sont des valeurs scalaires simples analysables et définissables sans contrainte sémantique. Cette classe comprend les entiers (en base 10) et les valeurs en virgule flottante (format défini par le langage hôte) ;
  2. Les valeurs de chaîne. Ce sont des chaînes simples ;
  3. Les valeurs abstraites du langage. Ce sont des valeurs comme celles de longueur et d'angle CSS, nécessitant une analyse plus complexe, mais pouvent produire des nombres interpolables.

L'élément animate peut interpoler les valeurs scalaires sans unité, et les éléments animate et set peuvent tous deux manipuler les valeurs de chaîne sans 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 de langage ces éléments devraient manipuler. Remarquez que l'élément animateColor manipule implicitement les valeurs abstraites des valeurs de couleur, et que l'élément animateMotion manipule implicitement les valeurs de position et de tracé.

Afin de permettre l'interpolation sur les attributs définissant des valeurs numériques avec certains types d'unités ou de qualificatifs (par exemple, "10px", "2.3feet", "$2.99"), il faut une gestion supplémentaire pour analyser et interpoler ces valeurs. On pourrait imposer au cadre d'animation d'intégrer une connaissance du type des valeurs qualifiées par des unités. Néanmoins, cela contredit le principe d'encapsulation et ne s'adapte pas hormis CSS aux langages XML définissant de nouveaux types de valeur d'attribut de cette forme.

L'approche recommandée pour une mise en œuvre d'animation dans un environnement hôte donné est la gestion de deux interfaces qui font abstraction de la manipulation des valeurs abstraites du langage. Nous ne définissons pas formellement ces interfaces mais les décrivons ainsi :

  1. La première interface convertit une chaîne (la valeur de la fonction d'animation) en un nombre canonique sans unité (soit un entier, soit une valeur en virgule flottante). Cela permet aux éléments d'animation d'interpoler entre les valeurs sans nécessiter une connaissance particulière des types de données, telles que des longueurs CSS. L'interface aura probablement besoin d'une référence vers l'attribut cible pour déterminer les valeurs abstraites légales. Si la chaîne passée ne peut se convertir en une valeur scalaire sans unité, l'élément d'animation traitera les valeurs de la fonction d'animation comme des chaînes, et l'attribut calcMode prendra la valeur par défaut "discrete" ;
  2. La seconde interface convertit un nombre canonique sans unité en une valeur de chaîne légale pour l'attribut cible. Par exemple, elle peut simplement convertir le nombre en une chaîne et lui accoler un suffixe d'unités canoniques. L'élément d'animation utilise le résultat obtenu pour fixer effectivement la valeur de présentation.

La gestion de ces deux interfaces permet d'assurer que le moteur d'animation n'aura pas besoin de copier l'analyseur et toute logique sémantique supplémentaire associée aux valeurs abstraites du langage.

Il ne s'agit pas d'une tentative pour définir comment la mise en œvre fournira cette gestion, plutôt d'une condition sur la façon d'interpréter les valeurs. Par exemple, les environnements d'animation ne devraient pas être tenus de comprendre les unités de longueur CSS ni pouvoir effectuer de conversions entre toutes ces unités. En outre, ce mécanisme permet d'appliquer une animation aux nouveaux langages XML, pourvu que la mise en œuvre du langage offre une gestion de l'analyse et de la conversion des valeurs des attributs.

Hormis les recommandations précédentes, il est parfois commode d'interpoler les valeurs dans un espace unitaire particulier et d'appliquer le résultat avec les unités définies au lieu des unités canoniques. Cela se vérifie tout particulièrement avec certaines unités relatives, comme celles définies par CSS (par exemple, l'unité em). Si l'animation définit toutes les valeurs dans la même unité, la mise en œuvre peut utiliser une connaissance de la syntaxe associée pour interpoler dans l'espace unitaire, et appliquer le résultat au sein du sandwich d'animation, selon les unités définies plutôt que les unités canoniques. Comme remarqué précédemment, cette solution s'adapte mal au cas général. Néanmoins, dans certaines applications (comme les propriétés CSS), il sera peut-être souhaitable d'adopter cette démarche.

3.8. La syntaxe courante des définitions DTD

Les attributs de temporisation

<!ENTITY % timingAttrs
  begin          CDATA  #IMPLIED 
  dur            CDATA  #IMPLIED
  end            CDATA  #IMPLIED
  restart        (always | never | 
                   whenNotActive)  "always"
  repeatCount    CDATA  #IMPLIED 
  repeatDur      CDATA  #IMPLIED
  fill           (remove | freeze) "remove"
>

Les attributs d'animation

<!ENTITY % animAttrs
  attributeName  CDATA  #REQUIRED
  attributeType  CDATA  #IMPLIED
  additive       (replace | sum) "replace"
  accumulate     (none | sum) "none"
>
<!ENTITY % animTargetAttr
  targetElement  IDREF  #IMPLIED
>
<!ENTITY % animLinkAttrs
  type     (simple | extended | locator | arc) #FIXED "simple"
  show     (new | embed | replace) #FIXED 'embed'
  actuate  (user | auto) #FIXED 'auto'
  href     CDATA  #IMPLIED
>

4. Les éléments d'animation

4.1. L'élément animate

L'élément animate introduit une animation d'attribut générique nécessitant peu ou aucune compréhension sémantique de l'attribut animé en question. Cet élément peut animer des scalaires numériques ainsi que des vecteurs numériques. Il peut également animer un seul attribut non numérique au travers d'un ensemble discret de valeurs. L'élément animate est un élément vide : il ne peut pas avoir de sous-élément.

Cet élément gère les attributs from/to/by et les descriptions de valeurs de la fonction d'animation, ainsi que tous les modes de calcul. Il gère tous les attributs de temporisation décrits. Tous ont été décrits dans les sections respectives précédentes.

<!ELEMENT animate EMPTY>
<!ATTLIST animate
  %timingAttrs
  %animAttrs
  calcMode       (discrete | linear | paced | spline ) "linear"
  values         CDATA  #IMPLIED
  keyTimes       CDATA  #IMPLIED
  keySplines     CDATA  #IMPLIED
  from           CDATA  #IMPLIED
  to             CDATA  #IMPLIED
  by             CDATA  #IMPLIED
>

Beaucoup d'exemples ont été fournis précédemment.

4.2. L'élément set

L'élément set permet de fixer simplement la valeur d'un attribut pour une durée définie. Comme pour tous les autres éléments d'animation, il manipule seulement la valeur de présentation, et l'effet ne s'applique plus à la fin de l'animation. C'est-à-dire que l'élément set ne fixe pas de façon permanente la valeur de l'attribut.

L'élément set gère tous les types d'attribut, y compris ceux qu'on ne peut pas raisonnablement interpoler et dont la sémantique revient plus logiquement à simplement fixer une valeur (par exemple, les chaînes et les valeurs booléennes). L'élément set est non additif. Les attributs additive et accumulate n'y sont pas admis et seront ignorés si définis.

L'élément set gère tous les attributs de temporisation pour définir les durées simples et actives. Toutefois, les attributs repeatCount et repeatDur affecteront simplement la durée active de l'élément set, en prolongeant l'effet de l'élément set (dans la mesure où la répétition d'une opération statique n'a pas vraiment de sens). Remarquez que l'utilisation de fill="freeze" avec l'élément set produira le même effet que la définition d'une temporisation pour une durée active "indefinite".

L'élément set utilise un jeu d'attributs plus réduit que l'élément animate (notamment, une seule valeur est définie et aucun contrôle d'interpolation n'est effectué) :

<!ELEMENT set EMPTY>
<!ATTLIST set
  %timingAttrs
  attributeName  CDATA  #REQUIRED
  attributeType  CDATA  #IMPLIED
  to             CDATA  #IMPLIED
>
to = "<valeur>"
Définit la valeur de l'attribut pour la durée de l'élément set. La valeur d'argument doit correspondre au type de l'attribut.

Exemples

L'exemple suivant change l'épaisseur de trait d'un rectangle SVG depuis la valeur originale jusqu'à une épaisseur de 5 pixels. L'effet débute à 5 secondes et dure 10 secondes après quoi la valeur originale est rétablie.

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

L'exemple suivant assigne la valeur de chaîne highlight à l'attribut class de l'élément text lorsque la souris se déplace sur l'élément, et supprime l'effet lorsque la souris en ressort.

<text>Ce texte sera en surbrillance au survol de la souris...
   <set attributeName="class" to="highlight" 
            begin="mouseover" end="mouseout" />
</text>

4.3. L'élément animateMotion

L'élément animateMotion déplace un élément le long d'un tracé. Cet élément réalise une abstraction de la notion de mouvement et de position au travers de divers mécanismes de disposition — le langage hôte définit le modèle de disposition et doit définir précisément la sémantique de position et de mouvement. On peut décrire le tracé de plusieurs façons :

Les valeurs doivent toutes être des couples de valeurs xy. Chaque valeur x et y peut indiquer toute unité de positionnement d'élément gérée par le langage hôte. Le langage hôte définit les unités par défaut. En outre, le langage hôte définit le point de référence pour positionner l'élément. C'est le point dans l'élément qui s'aligne sur la position décrite par l'animation de mouvement. Par défaut, certains langages placent le point de référence au coin supérieur gauche de la boîte englobante de l'élément ; pour d'autres langages, le point de référence peut être implicite, ou on peut le définir pour l'élément.

La syntaxe des couples de valeurs xy est la suivante :

coordinate-pair ::= ( coordinate comma-wsp coordinate )
coordinate      ::= nombre

Les valeurs de coordonnée sont séparées par au moins un caractère blanc ou une virgule. Les caractères blancs supplémentaires autour du séparateur sont admis. Les valeurs des termes coordinate doivent être définies comme un type de nombre dans le langage hôte.

Les attributs attributeName et attributeType ne sont pas utilisés avec l'élément animateMotion, puisque l'attribut (ou les attributs) de position manipulé est défini par le langage hôte. Si la position prend la forme d'un ou de plusieurs attributs qui sont également animables (par exemple, comme top et left, ou posX et posY), les mises en œuvre doivent combiner les animations animateMotion avec les autres animations manipulant des attributs de position individuels. Cf. également la section Le modèle d'animation en sandwich.

L'élément animateMotion fournit une syntaxe de remplacement supplémentaire : l'attribut path. Il permet de décrire un tracé en utilisant un sous-ensemble de la syntaxe de tracé SVG. Remarquez que si un tracé est défini, il annulera toute valeur définie par les attributs values ou from/to/by.

Comme indiqué dans la section Les valeurs de la fonction d'animation, si une valeur n'est pas légale (c'est-à-dire, les valeurs arguments des attributs from, to, by ou values, ou de l'attribut path), alors l'animation n'aura aucun effet (cf. également la section Le traitement des erreurs de syntaxe). Et de même si aucun des attributs from, to, by, values ou path n'est défini.

Le mode de calcul (calcMode) par défaut de l'élément animateMotion est "paced". Il produira un mouvement à vitesse constante au long du tracé défini. Quoique les éléments animateMotion peuvent être additifs, notez que l'addition de deux (ou plus) animations "paced" (à vitesse constante) ne résultera pas forcément en une animation de mouvements combinés à vitesse constante.

<!ELEMENT animateMotion EMPTY>
<!ATTLIST animateMotion
  %timingAttrs
  additive       (replace | sum) "replace"
  accumulate     (none | sum) "none"
  calcMode       (discrete | linear | paced | spline) "paced"
  values         CDATA  #IMPLIED
  from           CDATA  #IMPLIED
  to             CDATA  #IMPLIED
  by             CDATA  #IMPLIED
  keyTimes       CDATA  #IMPLIED
  keySplines     CDATA  #IMPLIED
  path           CDATA  #IMPLIED
  origin         (default) "default"
/>
path = "<description de tracé>"
Définit la courbe décrivant la valeur de l'attribut en fonction du temps. La syntaxe utilisée est un sous-ensemble de la syntaxe de tracé SVG. Cette gestion inclut les commandes pour décrire des droites (MmLlHhVvZz) et des courbes de Bézier (Cc). Cf. la définition des tracés dans SVG [SVG] pour des précisions.

Remarquez que SVG offre deux formes de commandes de tracé : l'une absolue (absolute) et l'autre relative (relative). Ces termes sembleront peut-être liés à la définition d'une animation additive et/ou à celle de l'attribut origin, pourtant ils sont orthogonaux. Les termes absolute et relative ne s'appliquent qu'à la définition du tracé en soi, et non au fonctionnement de l'animation. Les commandes relative définissent un tracé par rapport au point défini précédemment. Les termes absolute et relative ne sont pas liés aux définitions d'une animation additive et d'un attribut origin.

Un segment de données de tracé (ou segment de déplacement) doit commencer par l'une des commandes moveto.

Les commandes moveto — "M <x> <y>" ou "m <dx> <dy>"
Lancent un nouveau sous-tracé au point de coordonnées (xy). Si une commande moveto est suivie de plusieurs couples de coordonnées, alors ces couples sont traités comme des commandes lineto implicites.
Les commandes lineto — "L <x> <y>" ou "l <dx> <dy>"
Dessinent une ligne depuis le point courant jusqu'au point de coordonnées (xy) qui devient le nouveau point courant. On peut définir plusieurs couples de coordonnées pour dessiner une polyligne.
Les commandes lineto horizontales — "H <x>" ou "h <dx>"
Dessinent une ligne horizontale depuis le point courant (cpxcpy) jusqu'au point (xcpy). On peut fournir plusieurs valeurs x.
Les commandes lineto verticales — "V <y>" ou "v <dy>"
Dessinent une ligne verticale depuis le point courant (cpxcpy) jusqu'au point (cpxy). On peut fournir plusieurs valeurs y.
Les commandes closepath — "Z" ou "z"
Les commandes closepath dessinent automatiquement une ligne droite depuis le point courant jusqu'au point initial du sous-tracé courant.
Les commandes de courbe de Bézier cubique —
"C <x1> <y1> <x2> <y2> <x> <y>" ou
"c <dx1> <dy1> <dx2> <dy2> <dx> <dy>"
Dessinent une courbe de Bézier cubique depuis le point courant jusqu'au point (xy), en utilisant le point (x1y1) comme point de contrôle en début de courbe et le point (x2y2) comme point de contrôle en fin de courbe. On peut définir plusieurs ensembles de coordonnées pour dessiner un polybézier.

Lorsque l'attribut path est combiné aux paramètres "discrete", "linear" ou "spline" de l'attribut calcMode, le nombre de valeurs est défini comme le nombre de points définis par le tracé, à moins que le tracé ne contienne des commandes moveto. Une commande moveto ne définit pas de segment supplémentaire pour la temporisation ou l'interpolation. Une commande moveto ne compte pas comme point supplémentaire pour la segmentation de la durée, ou pour l'association des valeurs des attributs keyTimes et keySplines. Lorsque l'attribut path est combiné à un attribut calcMode valant "paced", toutes les commandes moveto sont censées avoir une longueur nulle (c'està-dire qu'elles se produisent toujours instantanément), et on ne devrait pas en tenir compte dans le calcul du rythme.

calcMode
Défini précédemment dans la section Les modes de calcul de la fonction d'animation, par contre notez que l'attribut calcMode de l'élément animateMotion vaut "paced" par défaut. Cela produira un mouvement à vitesse constante sur le tracé.

Il est permis d'utiliser un attribut calcMode valant "discrete" avec une définition d'attribut path, mais cela fera simplement passer l'élément cible d'un point à l'autre. Si l'attribut keyTimes n'est pas défini, les temps sont déduits de ceux de la définition de l'attribut path (comme décrit dans la section Les modes de calcul de la fonction d'animation).

L'utilisation d'un attribut calcMode valant "linear" avec plus de deux points décrits dans les attributs values, path ou keyTimes peut produire un mouvement à vitesse variable. La valeur "linear" de l'attribut calcMode indique que le temps est réparti équitablement entre les segments définis par les attributs values ou path (Remarque : la liste de l'attribut keyTimes éventuel définit le même nombre de segments). L'utilisation de la valeur "linear" n'indique pas que le temps soit réparti équitablement en fonction de la distance décrite par chaque segment.

Pour un mouvement à vitesse constante, on devrait fixer la valeur de l'attribut calcMode à "paced".

Pour contrôler entièrement la vitesse, on peut fixer la valeur de l'attribut calcMode à "spline", et l'auteur peut définir une spline de contrôle de vitesse avec les attributs keyTimes et keySplines.

origin = "default"
Définit l'origine du mouvement de l'animation. Les valeurs et la sémantique de cet attribut dépendent du modèle de disposition et positionnement du langage hôte. Dans certains langages, il peut n'y avoir qu'une seule option (c'est-à-dire la valeur "default"). Par contre, dans le positionnement CSS par exemple, on peut définir un tracé de mouvement par rapport au bloc conteneur ou par rapport à la position de la disposition de l'élément. Il est souvent commode de décrire un mouvement par rapport à la position de l'élément comme il est disposé (par exemple, depuis la gauche hors écran jusqu'à la position de la disposition, défini peut-être par from="(-100, 0)" et to="(0, 0)"). Les auteurs doivent pouvoir décrire le mouvement de cette façon ainsi que par rapport au bloc conteneur. L'attribut origin tient compte de cette distinction. Néanmoins, puisque c'est le langage hôte qui définit le modèle de disposition, il doit également définir le comportement pour la valeur "default", ainsi que toutes les valeurs d'attributs supplémentaires gérées.

Remarquez que la définition du modèle de disposition dans le langage hôte indique si les conteneurs ont des limites et le comportement d'un élément s'il se déplace hors des limites du conteneur de disposition. Par exemple, dans CSS2 [CSS2], on peut le contrôler avec la propriété clip.

Remarquez que pour une animation additive, la distinction opérée par l'attribut origin est dépourvue de sens. Cet attribut s'applique seulement si l'attribut additive vaut "replace".

4.4. L'élément animateColor

L'élément animateColor définit l'animation d'un attribut de couleur. Le langage hôte doit définir quels attributs décrivent des valeurs de couleur et sont capables d'une animation de couleur.

Toutes les valeurs doivent représenter des valeurs de couleur [sRGB]. La syntaxe de valeur légale des valeurs d'attributs est définie par le langage hôte.

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

<!ELEMENT animateColor EMPTY>
<!ATTLIST animateColor
  %animAttrs
  %timingAttrs
  calcMode       (discrete | linear
                  | paced | spline ) "linear"
  values         CDATA  #IMPLIED
  from           CDATA  #IMPLIED
  to             CDATA  #IMPLIED
  by             CDATA  #IMPLIED
  keyTimes       CDATA  #IMPLIED
  keySplines     CDATA  #IMPLIED
>

Les valeurs des attributs from/to/by et values peuvent indiquer des valeurs de couleur négatives et hors gamme de couleurs. La fonction définie par un élément animateColor individuel peut produire des valeurs négatives ou hors gamme. Les mises en œuvre doivent corriger la valeur de présentation résultante pour qu'elle soit valide dans l'espace colorimétrique de destination (écran). En revanche, comme décrit dans la section Le modèle d'animation en sandwich, elles devraient seulement corriger le résultat final combiné de toutes les animations de l'attribut donné, et non l'effet des animations individuelles.

Les valeurs sont corrigées par forçage des valeurs dans la gamme correcte. Les valeurs inférieures au minimum admis sont forcées à cette valeur minimale (habituellement "0", mais pas obligatoirement avec certains profils de couleurs). Les valeurs supérieures au maximum défini sont forcées à cette valeur maximale (définie par le langage hôte).

Remarquez que les valeurs de couleur sont corrigées en les forçant dans la gamme de couleurs de l'espace colorimétrique de destination (écran). Certaines mises en œuvre ne pourront peut-être pas traiter les valeurs situées hors de l'espace colorimétrique source (sRGB), et elles devront donc les forcer dans cet espace colorimétrique, puis les convertir dans l'espace colorimétrique de destination et les forcer à nouveau dans sa gamme de couleurs. Il s'agit de faire la distinction entre la gamme de couleurs de la source et celle de la destination, pour un forçage le plus tard possible, et de réaliser que certains appareils comme les imprimantes à jet d'encre, qui semblent être des appareils RGB, ont des gammes de couleurs non cubiques.

Note aux développeurs : Lorsque l'élément animateColor est défini comme une animation to, la fonction d'animation devrait supposer une distance RGB cubique euclidienne où on doit calculer les deltas. Cf. également les sections Les valeurs de la fonction d'animation et Comment les attributs from, to et by affectent-ils le comportement additif. De même, lorsque l'attribut calcMode de l'élément animateColor vaut "paced", la fonction d'animation devrait supposer une distance RGB cubique euclidienne pour calculer la distance et le rythme.

5. L'intégration de SMIL Animation à un langage hôte

Cette section décrit ce qu'un concepteur de langage doit effectivement faire pour définir l'intégration de SMIL Animation dans un langage hôte. Elle comprend les définitions de base, les contraintes sur l'animation, et les événements permis et ceux pris en charge.

5.1. Les définitions obligatoires du langage hôte

Le concepteur du langage hôte doit définir des concepts de base dans le contexte du langage hôte particulier. Ils constituent l'assise de la sémantique de temporisation et de présentation.

Le concepteur du langage hôte doit définir ce que signifie présentation du document. L'exemple typique est celui d'un document affiché à l'écran.

Le concepteur du langage hôte doit définir le début du document. Comme définitions possibles, le document débute dès qu'un client a reçu le document entier depuis un réseau, ou le document débute dès que certaines parties ont été reçues.

Le concepteur du langage hôte doit définir la fin du document. Elle a lieu habituellement lorsque l'application associée quitte ou bien lorsque son contexte bascule vers un autre document.

Le langage hôte devrait fournir une méthode pour identifier chaque élément d'animation dans un document de façon unique. Le service offert devrait être le même que pour les autres éléments dans le langage. Par exemple, puisque SMIL 1.0 identifie chaque élément avec un attribut id contenant une valeur de type ID XML pour cet élément, les éléments d'animation ajoutés à SMIL 1.0 devraient également avoir un attribut id.

5.2. Les définitions et les conditions obligatoires des cibles d'animation

La définition de l'élément cible

Le concepteur du langage hôte doit choisir entre utiliser l'attribut targetElement, ou bien les attributs XLink, pour définir l'élément cible. Remarquez que s'il utilise la syntaxe XLink, le concepteur du langage hôte doit décider de la façon d'indiquer l'espace de nommage XLink des attributs associés. L'espace de nommage peut être fixé dans une définition DTD, ou bien le concepteur du langage peut imposer des noms d'attributs à caractères deux-points (qnames) pour indiquer l'espace de nommage XLink des attributs. Les attributs XLink obligatoires ont des valeurs fixes, et on peut donc aussi les définir dans une définition DTD ou les imposer sur les éléments d'animation. Le concepteur du langage hôte peut imposer que les attributs XLink optionnels soient définis. Ces décisions sont laissées à l'appréciation du concepteur du langage hôte ; les informations de syntaxe des attributs XLink n'affectent pas la sémantique de SMIL Animation.

En général, n'importe quel élément dans le document peut être un élément cible. Le concepteur de langage hôte doit définir toutes les exceptions sur ce point. On déconseille au concepteur qu'il permette à un élément d'animation de viser des éléments situés hors du document où il est défini. La syntaxe XLink de l'élément cible pourrait l'autoriser, toutefois cette version de SMIL Animation ne définit pas la sémantique de temporisation et d'animation SMIL pour cela.

Les problèmes des attributs cibles

Les définitions dans ce module peuvent servir à animer n'importe quel attribut de n'importe quel élément dans un document hôte. Quoiqu'il en soit, le concepteur d'un langage hôte intégrant SMIL Animation peut restreindre la gamme d'éléments et d'attributs capables d'animation. Par exemple, un langage hôte peut ne pas prendre en charge l'animation de l'attribut language d'un élément script. Un langage hôte avec une définition de fonctionnalité DOM pourrait réserver l'animation aux attributs légalement modifiables au travers du DOM.

Tout attribut d'un élément quelconque dont l'animation n'est pas explicitement exclue par le langage hôte est animable, tant que le type de données sous-jacent (que le langage hôte définit pour l'attribut) gère les valeurs discrètes (pour une animation discrète) et/ou l'addition (pour une animation interpolée et additive).

Toutes les contraintes d'animation doivent être décrites dans la définition du langage hôte ou dans un schéma approprié, car la seule définition DTD ne peut pas raisonnablement les exprimer.

Le langage hôte doit définir quelles sont les valeurs abstraites du langage à manipuler pour les attributs animés. Par exemple, un langage hôte intégrant CSS peut imposer la gestion des valeurs de longueur CSS. Ces questions sont précisées dans la section Le détail des valeurs de la fonction d'animation.

Le langage hôte doit définir l'interprétation des valeurs relatives. Par exemple, si une valeur est définie comme un pourcentage de la dimension d'un conteneur, le langage hôte doit définir si cette valeur est à interpréter dynamiquement au cours de l'animation de la dimension du conteneur.

Le langage hôte doit définir la sémantique de forçage des valeurs d'attributs. Il doit définir toutes les gammes de valeurs définies et comment traiter les valeurs hors gamme.

Le langage hôte doit définir les formats reconnus pour les valeurs d'attribut numériques. Elles comprennent les valeurs entières et spécialement les valeurs en virgule flottante d'attributs tels que keyTimes et keySplines. Comme minimum raisonnable, on encourage les concepteurs de langages hôtes à utiliser le format décrit dans [CSS2]. Dans la spécification CSS, la référence spécifique pour ces types de données est 4.3.1 Les entiers et les nombres réels.

L'intégration des fonctionnalités de l'élément animateMotion

La spécification du langage hôte doit définir quels éléments peuvent être ciblés par l'élément animateMotion. En outre, elle doit décrire le modèle de positionnement des éléments et doit décrire le modèle de l'élément animateMotion dans ce contexte (c'est-à-dire qu'elle doit définir la sémantique de la valeur "default" de l'attribut origin). Si une position peut être décrite de plusieurs façons, les autres valeurs de l'attribut origin devraient être définies pour permettre aux auteurs de contrôler le modèle de positionnement.

Un exemple d'intégration de langage : SVG

Comme exemple, le langage SVG [SVG] intégrant SMIL Animation. Il définit les éléments, attributs et propriétés CSS pouvant être animés. Certains attributs (par exemple, viewbox et fill-rule) gèrent seulement l'animation discrète, et d'autres (par exemple, width, opacity et stroke) l'animation interpolée et additive. L'attribut xlink:actuate sur l'élément use constitue un exemple d'attribut non animable.

Le langage SVG précise le format des valeurs numériques, en décrivant les gammes légales et permettant une notation scientifique (exponentielle) des valeurs en virgule flottante.

5.3. Les contraintes de manipulation des éléments d'animation

Les concepteurs de langages intégrant SMIL Animation sont invités à ne pas admettre la manipulation des attributs des éléments d'animation après le début du document. Sont concernés les attributs définissant des cibles et des valeurs ainsi que les attributs de temporisation. En particulier, l'attribut id (de type ID) sur tous les éléments d'animation ne doit pas être variable (c'est-à-dire qu'il devrait être en lecture seule). Imposer aux moteurs d'exécution des animations un suivi des changements de valeur des attributs id introduit une complexité considérable, pour un intérêt pour le moins discutable.

On recommande que les spécifications de langages rejettent la manipulation des attributs des éléments d'animation au travers des interfaces DOM après le début du document. On recommande également qu'elles rejettent l'utilisation d'éléments d'animation pour viser d'autres éléments d'animation.

Notez en particulier que si l'attribut attributeName peut changer (du fait de l'animation, ou bien du fait d'un script), alors des problèmes peuvent apparaître si le nom de l'attribut cible est qualifié par espace de nommage. Les spécifications actuelles du DOM n'incluent aucun mécanisme pour utiliser cette liaison.

Le changement dynamique des valeurs d'attribut des éléments d'animation introduit dans le modèle des complications sémantiques encore insuffisamment étudiées. Cette contrainte sera peut-être levée dans une version future de SMIL Animation.

5.4. Les définitions et contraintes obligatoires de la temporisation des éléments

Cette spécification suppose que les éléments d'animations soient les seuls dans le langage hôte à avoir une sémantique de temporisation (cette restriction sera peut-être levée dans une version future de SMIL Animation). Elle ne peut pas servir avec un langage hôte contenant des éléments avec une sémantique de temporisation. Par exemple, il est illégal d'intégrer l'animation suivante dans le langage SMIL 1.0 avec la version actuelle de SMIL Animation :

<par id="exempleInvalide">
  <img begin="2s" dur="1m" src="foo.png" alt="Triste figure pour mauvais exemple" />
    <anchor id="anc" href="#bar" coords="0%,0%,50%,50%" dur="30s" />
    <set targetElement="anc" attributeName="coords" 
         begin="10s" dur="20s" fill="freeze"
         to="50%,50%,100%,100%" />
  </img>
</par>

L'ensemble des éléments d'animation admettant une temporisation comprend les éléments définis dans cette spécification et les éléments d'animation d'extensions définis dans le langage hôte. Les éléments d'animation d'extensions doivent se conformer au cadre d'animation décrit dans ce document. En particulier, on ne peut pas définir d'éléments d'animation d'extensions contenant d'autres éléments d'animation, qui introduiraient une temporisation hiérarchique, comme celle utilisée par les éléments par et seq de SMIL 1.0 [SMIL].

Les événements pris en charge pour la temporisation par événements

Le langage hôte doit définir quels noms d'événements sont valides comme valeurs d'événement. Si le langage hôte ne définit aucun nom d'événement admis, la temporisation par événements est en fait exclue pour le langage hôte.

Les langages hôtes peuvent définir que les événements créés dynamiquement (selon la spécification [DOM2Events]) constituent des noms d'événements valides, et ne pas lister explicitement les noms admis.

5.5. La sémantique du traitement des erreurs

Le concepteur du langage hôte peut imposer des contraintes plus strictes sur la sémantique du traitement des erreurs. À savoir, en cas d'erreurs de syntaxe, le langage hôte peut définir les mécanismes supplémentaires ou plus stricts à utiliser pour indiquer une erreur. Par exemple, interrompre tout le traitement du document, ou arrêter toute l'animation.

Les concepteurs de langages hôtes peuvent ne pas relâcher les définitions du traitement des erreurs, ou la réponse du traitement des erreurs (comme décrit dans la section Le traitement des erreurs de syntaxe). Par exemple, les concepteurs de langages hôtes ne sont pas obligés de définir une sémantique de reprise sur erreur pour les valeurs manquantes ou erronées des attributs values ou keyTimes.

5.6. L'espace de nommage de SMIL Animation

Les concepteurs de langages peuvent opter d'intégrer SMIL Animation comme un espace de nommage indépendant, ou peuvent intégrer les noms SMIL Animation dans un nouvel espace de nommage défini comme partie du langage hôte. Les concepteurs de langage souhaitant placer la fonctionnalité SMIL Animation dans un espace de nommage isolé devraient utiliser l'espace de nommage suivant :

http://www.w3.org/2001/smil-animation

6. La gestion du modèle objet de document

Tout langage fondé sur XML et intègrant SMIL Animation héritera des interfaces de base définies dans le DOM [DOM2Core] (quoique les langages ne nécessitent pas tous une mise en œuvre du DOM). Le langage SMIL Animation définit l'interaction de l'animation et du DOM. SMIL Animation définit également des contraintes sur les interfaces DOM de base, et les interfaces DOM spécifiques utilisées par SMIL Animation.

Remarquez que le concepteur du langage intégrant SMIL Animation doit définir toutes les contraintes sur SMIL Animation concernant le DOM. Cela comprend la définition des attributs du langage pouvant être animés ou non, ainsi que la définition de l'addition pour tous les attributs gérant l'animation additive.

6.1. Les événements et le modèle d'événement

Cette section est informative

La temporisation interactive SMIL suppose que le langage hôte gère les événements et qu'on puisse les associer par déclaration. La spécification DOM niveau 2 — Events [DOM2Events] en décrit le fonctionnement.

Cette section est normative

Les événements spécifiques pris en charge sont définis par le langage hôte. S'il ne définit aucun événement, la temporisation interactive est en fait omise.

Ce module définit un jeu d'événements que le langage hôte peut inclure. Il comprend :

beginEvent
Cet événement est suscité au commencement de l'exécution de la ligne de temps locale de l'élément. Il sera suscité à chaque fois que l'élément débutera la durée active (c'est à dire lorsqu'il est relancé mais pas lorsqu'il se répète). Il peut être suscité tant dans le cours normal (c.à.d. programmé ou interactif) de l'exécution de la ligne de temps, qu'au moment où l'élément débute du fait d'une méthode DOM.
endEvent
Cet événement est suscité à la fin active de l'élément. Remarquez qu'il n'est pas suscité pour la fin simple de chaque répétition. Il peut être suscité tant dans le cours normal (c'est-à-dire programmé ou interactif) de l'éxécution de la ligne de temps, qu'au moment où l'élément se termine du fait d'une méthode DOM.
repeat
Cet événement est suscité à la répétition de la ligne de temps de l'élément, après la première itération. Un entier associé à l'événement repeat indique quelle itération de répétition commence. Cet entier commence à zéro, mais puisque l'événement repeat n'est pas suscité à la première itération, ses valeurs observées seront donc supérieures ou égales à un.

Si l'élément est relancé pendant son exécution, il suscitera un événement endEvent puis un événement beginEvent à la relance.

L'événement beginEvent ne sera peut-être pas suscité pour le temps de début calculé d'un élément. Par exemple, l'élément peut définir un temps de début antérieur au début du document (avec une valeur de décalage négative, ou bien avec un temps de base de synchronisation se résolvant en un temps antérieur au début du document). Auquel cas, il sera défini un dépendant temporel du temps de base de synchronisation de début, relatif au temps de début calculé. L'événement beginEvent est suscité lorsque l'élément débute réellement (dans l'exemple, au début du document). De même, l'événement endEvent est suscité lorsque l'élément se termine réellement, à un temps peut-être différent du temps de fin calculé (par exemple, si la fin est définie comme un décalage négatif depuis un événement de l'utilisateur). Cf. également les explications dans la section La propagation des changements aux temps.

6.2. Les interfaces prises en charge

Le langage SMIL Animation utilise plusieurs méthodes pour contrôler le comportement d'une animation : beginElement(), beginElementAt(), endElement() et endElementAt(). Ces méthodes servent à débuter ou à terminer la durée active d'un élément. Les auteurs peuvent (sans obligation) déclarer la temporisation pour répondre au DOM en utilisant la syntaxe suivante :

<animate begin="indefinite" end="indefinite" .../>

Lorsqu'on appelle une méthode DOM pour débuter ou terminer l'élément (avec beginElement(), beginElementAt(), endElement() ou endElementAt()), chaque appel crée un seul temps d'instance (dans la liste de temps d'instance concernée). Ces temps sont ensuite interprétés dans le cadre de la sémantique des listes de temps, comme décrit dans la section L'évaluation des listes de temps de début et de fin.

On attend de l'interface suivante qu'elle permette d'obtenir une instance de l'interface ElementTimeControl en utilisant des méthodes de forçage spécifiques de la liaison sur une instance d'élément animate. L'application DOM peut utiliser la méthode hasFeature de l'interface DOMImplementation pour déterminer si l'interface ElementTimeControl est prise en charge ou non. La chaîne caractéristique de cette interface est "TimeControl".

Interface ElementTimeControl

Définition IDL
interface ElementTimeControl {
  boolean            beginElement();
  boolean            beginElementAt(in float offset));
  boolean            endElement();
  boolean            endElementAt(in float offset);
};
Méthodes
beginElement
Crée un temps d'instance de début du temps courant.
Valeur retournée
void
Aucun paramètre
beginElementAt
Crée un temps d'instance de début du temps courant, plus ou moins le décalage passé.
Paramètres
float offset Le décalage en secondes où débuter l'élément.
Valeur retournée
void
endElement
Crée un temps d'instance de fin du temps courant.
Valeur retournée
void
Aucun paramètre
endElementAt
Crée un temps d'instance de fin du temps courant, plus ou moins le décalage passé.
Paramètres
float offset Le décalage en secondes où terminer l'élément. Il doit être supérieur ou égal à 0.
Valeur retournée
void
Interface TimeEvent
L'interface TimeEvent fournit les informations contextuelles spécifiques associées aux événements de temps.

Définition IDL
interface TimeEvent : events::Event {
  readonly attribute views::AbstractView  view;
  readonly attribute long             detail;
  void               initTimeEvent(in DOMString typeArg, 
                                   in views::AbstractView viewArg, 
                                   in long detailArg);
};
Attributs
view de type views::AbstractView, en lecture seule
L'attribut view identifie l'objet AbstractView d'où l'événement a été généré.
detail de type long, en lecture seule
Fournit des informations particulières à propos l'objet Event, selon le type d'événement.
Méthodes
initTimeEvent
La méthode initTimeEvent sert à initialiser la valeur d'un objet TimeEvent créé au travers de l'interface DocumentEvent. On peut seulement appeler cette méthode avant la distribution de l'objet TimeEvent par la méthode dispatchEvent, quoiqu'on puisse l'appeler plusieurs fois pendant cette phase si nécessaire. Si elle est appelée plusieurs fois, l'invocation finale a priorité.
Paramètres
DOMString typeArg Indique le type d'événement.
views::AbstractView viewArg Définit la vue AbstractView de l'objet Event.
long detailArg Fournit des informations à propos de l'objet Event.
Aucune valeur retournée
Aucune exception

Les différents types d'événements pouvant se produire sont les suivants :

begin
Suscité lorsque l'élément débute. Cf. également la section Les événements et le modèle d'événement.
  • Bouillonne : non
  • Annulable : non
  • Informations contextuelles : aucune
end
Suscité lorsque l'élément termine sa durée active. Cf. également la section Les événements et le modèle d'événement.
  • Bouillonne : non
  • Annulable : non
  • Informations contextuelles : aucune
repeat
Suscité lorsque l'élément se répète. Cf. également la section Les événements et le modèle d'événement.
  • Bouillonne : non
  • Annulable : non
  • Informations contextuelles : detail (itération courante)

6.3. La définition IDL

smil.idl:

// Fichier : smil.idl
#ifndef _SMIL_IDL_
#define _SMIL_IDL_

#include "dom.idl"

#pragma prefix "dom.w3c.org"
module smil
{
  typedef dom::DOMString DOMString;

  interface ElementTimeControl {
    void            beginElement();
    void            beginElementAt(in float offset);
    void            endElement();
    void            endElementAt(in float offset);
  };

  interface TimeEvent : events::Event {
    readonly attribute views::AbstractView  view;
    readonly attribute long             detail;
    void               initTimeEvent(in DOMString typeArg, 
                                     in views::AbstractView viewArg, 
                                     in long detailArg);
  };
};

#endif // _SMIL_IDL_

6.4. La liaison de langage Java

org/w3c/dom/smil/ElementTimeControl.java:

package org.w3c.dom.smil;

import org.w3c.dom.DOMException;

public interface ElementTimeControl {
    public void  beginElement();

    public void  beginElementAt(float offset);

    public void endElement();

    public void endElementAt(float offset);

}

org/w3c/dom/smil/TimeEvent.java:

package org.w3c.dom.smil;

import org.w3c.dom.events.Event;
import org.w3c.dom.views.AbstractView;

public interface TimeEvent extends Event {
    public AbstractView getView();

    public int getDetail();

    public void initTimeEvent(String typeArg, 
                              AbstractView viewArg, 
                              int detailArg);

}

6.5. La liaison de langage ECMAScript

Objet ElementTimeControl
L'objet ElementTimeControl possède les méthodes suivantes :
beginElement()
Cette méthode retourne void.
beginElementAt(offset)
Cette méthode retourne void. Le paramètre offset est de type float.
endElement()
Cette méthode retourne void.
endElementAt(offset)
Cette méthode retourne void. Le paramètre offset est de type float.
Objet TimeEvent
L'objet TimeEvent possède toutes les propriétés et méthodes de l'interface Event ainsi que les propriétés et méthodes définies ci-dessous.
L'objet TimeEvent possède les propriétés suivantes :
view
Cette propriété est de type AbstractView.
detail
Cette propriété est de type long.
L'objet TimeEvent possède les méthodes suivantes :
initTimeEvent(typeArg, viewArg, detailArg)
Cette méthode retourne void. Le paramètre typeArg est de type DOMString. Le paramètre viewArg est de type views::AbstractView. Le paramètre detailArg est de type long.

7. Annexe : Les différences avec le modèle de temporisation de SMIL 1.0

8. Références

[CSS2]
Les feuilles de style en cascade, niveau 2, B. Bos, H. W. Lie, C. Lilley, I. Jacobs, 12 mai 1998.
Disponible à http://www.w3.org/TR/REC-CSS2.
[COMP-GRAPHICS]
Computer Graphics : Principles and Practice, Second Edition, James D. Foley, Andries van Dam, Steven K. Feiner, John F. Hughes, Richard L. Phillips, Addison-Wesley, pp. 488-491.
[DATETIME]
Les formats des dates et des heures, M. Wolf, C. Wicksteed. Note du W3C du 27 août 1998.
Disponible à http://www.w3.org/TR/NOTE-datetime
[DOM2Core]
La spécification du modèle objet de document (DOM) niveau 2 — Core
Disponible à http://www.w3.org/TR/DOM-Level-2/.
[DOM2CSS]
La spécification du modèle objet de document (DOM) niveau 2 — Style
Disponible à http://www.w3.org/TR/DOM-Level-2-Style/css.html.
[DOM2Events]
La spécification du modèle objet de document (DOM) niveau 2 — Events, T. Pixley
Disponible à http://www.w3.org/TR/DOM-Level-2-Events/events.html.
[HTML]
La spécification HTML 4.01, D. Raggett, A. Le Hors, I. Jacobs, 24 décembre 1999.
Disponible à http://www.w3.org/TR/REC-html40.
[ISO8601]
Data elements and interchange formats - Information interchange - Representation of dates and times, International Organization for Standardization, 1998.
[ISO10646]
Information Technology -- Universal Multiple-Octet Coded Character Set (UCS) -- Part 1: Architecture and Basic Multilingual Plane, ISO/IEC 10646-1:1993. Cette référence correspond à un ensemble de points de code (N.d.T. codepoints) susceptible d'évoluer au fur et à mesure que sont assignés de nouveaux caractères. Elle inclut donc les futurs amendements, tant qu'ils ne changent pas les assignations de caractères dans les cinq premiers amendements (y inclus le dernier) de la norme ISO/IEC 10646-1:1993. Également, cette référence suppose que les jeux de caractères (N.d.T. character sets) définis par la norme ISO 10646 et Unicode restent équivalents caractère pour caractère. Cette référence comprend aussi les publications futures des autres parties de la norme ISO 10646 (c'est-à-dire pas la première partie) qui définissent les caractères des plans 1 à 16.
[SMIL1.0]
Spécification du langage d'intégration multimédias synchronisés (SMIL) 1.0, recommandation du W3C du 15 juin 1998.
Disponible à http://www.w3.org/TR/REC-smil.
[SMIL20]
Spécification du langage d'intégration multimédias synchronisés (SMIL 2.0)
Recommandation proposée du W3C
Disponible à http://www.w3.org/TR/smil20/
[SMIL-MOD]
Les modules multimédias synchronisés basés sur SMIL 1.0, Patrick Schmitz, Ted Wugofski, Warner ten Kate.
Disponible à http://www.w3.org/TR/NOTE-SYMM-modules.
[sRGB]
IEC 61966-2-1 (1999-10) - Multimedia systems and equipment - Colour measurement and management - Part 2-1: Colour management - Default RGB colour space - sRGB, ISBN: 2-8318-4989-6 ­ ICS codes: 33.160.60, 37.080 ­ TC 100 ­ 51 pp.
Disponible à http://www.iec.ch/nr1899.htm.
[SVG]
Spécification des graphiques vectoriels adaptables (SVG) 1.0, recommandation proposée du W3C du 19 juillet 2001.
Disponible à http://www.w3.org/TR/SVG/.
[XLink]
Le langage de liaison XML (XLink), S. DeRose, E. Maler, D. Orchard, rédacteurs, 27 juin 2001.
Disponible à http://www.w3.org/TR/xlink
[XML]
Le langage de balisage extensible (XML) 1.0, T. Bray, J. Paoli, C.M. Sperberg-McQueen, Eve Maler, rédacteurs, 6 octobre 2000.
Disponible à http://www.w3.org/TR/REC-xml
[XML-NS]
Les espaces de nommage dans XML, T. Bray, D. Hollander, A. Layman, rédacteurs, 14 janvier 1999.
Disponible à http://www.w3.org/TR/REC-xml-names/.