Vue d'ensemble des événements de minutage

Cette rubrique explique comment utiliser les cinq événements de minutage disponibles sur et Clock les Timeline objets.

Prérequis

Pour comprendre cette rubrique, vous devez être en mesure de créer et d’utiliser des animations. Pour commencer avec les animations, consultez l’article Vue d’ensemble de l’animation.

Il existe plusieurs façons d’animer des propriétés dans WPF :

• Utilisation d’objets storyboard (balisage et code) : vous pouvez utiliser Storyboard des objets pour organiser et distribuer des animations à un ou plusieurs objets. Si vous voulez voir un exemple, consultez l’article Comment : animer une propriété à l'aide d'un storyboard.

• À l’aide d’animations locales (code uniquement) : vous pouvez appliquer AnimationTimeline des objets directement aux propriétés qu’ils animent. Si vous voulez voir un exemple, consultez l’article Comment : animer une propriété sans utiliser de storyboard.

• En utilisant des horloges (code uniquement) : vous pouvez gérer la création d’horloge explicitement et distribuer vous-même les horloges d’animation. Si vous voulez voir un exemple, consultez l’article Comment : animer une propriété à l'aide d'un AnimationClock.

Étant donné que vous pouvez les utiliser dans le balisage et le code, les exemples de cette vue d’ensemble utilisent des Storyboard objets. Toutefois, les concepts décrits sont applicables aux autres méthodes d’animation des propriétés.

Qu’est-ce qu’une horloge ?

Une chronologie, par elle-même, ne fait rien d’autre que décrire un segment de temps. Il s’agit de l’objet chronologie Clock qui effectue le travail réel : il gère l’état d’exécution lié au minutage pour le chronologie. Dans la plupart des cas, par exemple quand vous utilisez des tables de montage séquentiel, une horloge est créée automatiquement pour votre chronologie. Vous pouvez également créer un Clock élément explicitement à l’aide de la CreateClock méthode. Pour plus d’informations sur les objets, consultez la vue d’ensemble Clockdu système d’animation et de minutage.

Pourquoi utiliser des événements ?

À une exception près (seekAlignedToLastTick), toutes les opérations de minutage interactives sont asynchrones. Il n’existe aucun moyen de savoir exactement quand elles s’exécutent. Ceci peut être un problème lorsque vous avez d’autres codes qui dépendent de l’opération de minutage. Supposons que vous souhaitiez arrêter une chronologie qui animait un rectangle. Après l’arrêt de la chronologie, vous modifiez la couleur du rectangle.

myStoryboard.Stop(myRectangle);

// This statement might execute
// before the storyboard has stopped.
myRectangle.Fill = Brushes.Blue;

myStoryboard.Stop(myRectangle)

' This statement might execute
' before the storyboard has stopped.
myRectangle.Fill = Brushes.Blue

Dans l’exemple précédent, la deuxième ligne de code peut s’exécuter avant l’arrêt de la table de montage séquentiel. Cela est dû au fait que l’arrêt est une opération asynchrone. Si vous demandez à une chronologie ou à une horloge de s’arrêter, elle crée une « demande d’arrêt » qui n’est pas traitée avant le prochain battement du moteur de minutage.

Pour exécuter des commandes après la fin d’une chronologie, utilisez les événements de minutage. Dans l’exemple suivant, un gestionnaire d’événements est utilisé pour modifier la couleur d’un rectangle, après l’arrêt de la table de montage séquentiel.

// Register for the CurrentStateInvalidated timing event.
myStoryboard.CurrentStateInvalidated += new EventHandler(myStoryboard_CurrentStateInvalidated);

' Register for the CurrentStateInvalidated timing event.
AddHandler myStoryboard.CurrentStateInvalidated, AddressOf myStoryboard_CurrentStateInvalidated

// Change the rectangle's color after the storyboard stops.
void myStoryboard_CurrentStateInvalidated(object sender, EventArgs e)
{
    Clock myStoryboardClock = (Clock)sender;
    if (myStoryboardClock.CurrentState == ClockState.Stopped)
    {
        myRectangle.Fill = Brushes.Blue;
    }
}

' Change the rectangle's color after the storyboard stops. 
Private Sub myStoryboard_CurrentStateInvalidated(ByVal sender As Object, ByVal e As EventArgs)
    Dim myStoryboardClock As Clock = CType(sender, Clock)
    If myStoryboardClock.CurrentState = ClockState.Stopped Then
        myRectangle.Fill = Brushes.Blue
    End If
End Sub

Pour obtenir un exemple plus complet, consultez la page Comment : recevoir une notification en cas de changement d'état de l'horloge.

Événements publics

Les Timeline classes et Clock les deux fournissent cinq événements de minutage. Le tableau suivant répertorie ces événements et les conditions qui les déclenchent.

Cycles et regroupement des événements

Lorsque vous animez des objets dans WPF, il s’agit du moteur de minutage qui gère vos animations. Le moteur de minutage suit l’écoulement du temps et calcule l’état de chaque animation. Il effectue plusieurs calculs de ce type en une seconde. Ces calculs sont appelés « cycles ».

Étant donné que ces cycles sont fréquents, beaucoup de choses peuvent se passer entre chaque cycle. Par exemple, une chronologie peut s’arrêter, démarrer et s’arrêter à nouveau. Dans ce cas, son état actuel aura changé trois fois. En théorie, l’événement peut être déclenché plusieurs fois dans un seul cycle. Toutefois, le moteur de minutage regroupe les événements, afin que chacun ne puisse être déclenché qu’une fois par cycle.

Inscription pour des événements

Il existe deux façons d’inscrire des événements de minutage : vous pouvez les inscrire avec la chronologie ou avec l’horloge créée à partir de la chronologie. Il est assez simple d’inscrire un événement directement avec une horloge, mais il n’est possible de le faire qu’à partir du code. Vous pouvez inscrire des événements avec une chronologie, à partir d’une balise ou du code. La section suivante décrit comment inscrire les événements d’horloge avec une chronologie.

Inscription des événements d’horloge avec une chronologie

Bien qu’un chronologie’s Completed, , CurrentGlobalSpeedInvalidatedCurrentStateInvalidated, CurrentTimeInvalidatedet RemoveRequested les événements semblent être associés à l’chronologie, l’inscription de ces événements associe réellement un gestionnaire d’événements au Clock gestionnaire d’événements créé pour le chronologie.

Lorsque vous vous inscrivez à l’événement Completed sur un chronologie, par exemple, vous indiquez au système de s’inscrire à l’événement Completed de chaque horloge créée pour le chronologie. Dans le code, vous devez vous inscrire à cet événement avant la Clock création de ce chronologie ; sinon, vous ne recevrez pas de notification. Cela se produit automatiquement en XAML ; l’analyseur s’inscrit automatiquement à l’événement avant la création de l’analyseur Clock .

Voir aussi

• Vue d’ensemble de l’animation et du système de minutage
• Vue d’ensemble de l’animation
• Vue d’ensemble des comportements de minutage