Vue d’ensemble des événements de chronométrage

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

Conditions préalables

Pour comprendre cette rubrique, vous devez comprendre comment créer et utiliser des animations. Pour commencer à utiliser l’animation, consultez la 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. Pour obtenir un exemple, consultez 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. Pour obtenir un exemple, consultez Animer une propriété sans utiliser un storyboard.

• À l’aide d’horloges (code uniquement) : vous pouvez gérer explicitement la création d’horloges et distribuer vous-même les horloges d’animation. Pour obtenir un exemple, consultez 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 peuvent être appliqués aux autres méthodes d’animation des propriétés.

Qu’est-ce qu’une horloge ?

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

Pourquoi utiliser des événements ?

À l’exception d'un (positionnement aligné sur le dernier repère), toutes les opérations de minutage interactives sont asynchrones. Il n’existe aucun moyen pour vous de savoir exactement quand ils s’exécuteront. Cela peut être un problème lorsque vous avez d’autres codes qui dépendent de votre opération de minutage. Supposons que vous vouliez arrêter une animation qui animait un rectangle. Une fois la chronologie arrêtée, 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 du storyboard. Cela est dû au fait que l’arrêt est une opération asynchrone. Indiquer à une chronologie ou à une horloge de s’arrêter crée une sorte de « demande d’arrêt » qui n’est pas traitée avant le prochain tic du moteur de minutage.

Pour exécuter des commandes après la fin d’une ligne de temps, utilisez des événements de synchronisation. 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 lecture du storyboard.

// 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 Recevoir une notification lorsque l’état d’une horloge change.

Événements publics

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

Enregistrement et consolidation d’é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 la progression du temps et calcule l’état de chaque animation. Il réalise plusieurs évaluations de ce type par seconde. Ces passes d’évaluation sont appelées « cycles ».

Bien que les tics se produisent fréquemment, il est possible que de nombreuses choses se produisent entre les tics. Par exemple, une chronologie peut être arrêtée, démarrée et arrêtée à nouveau, auquel cas son état actuel aura changé trois fois. En théorie, l’événement peut être déclenché plusieurs fois dans une seule graduation ; Toutefois, le moteur de minutage consolide les événements afin que chaque événement puisse être déclenché au plus une fois par graduation.

Inscription aux événements

Il existe deux façons de s’inscrire aux événements chronométrés : vous pouvez vous inscrire selon la chronologie ou avec l’horloge créée à partir de la chronologie. L’inscription d’un événement directement avec une horloge est assez simple, même si elle ne peut être effectuée qu’à partir du code. Vous pouvez vous inscrire à des événements avec une chronologie à partir du balisage ou du code. La section suivante explique comment s’inscrire aux événements d’horloge avec une chronologie.

Inscription d’événements d’horloge à l’aide d’une chronologie

Bien que les événements Completed, CurrentGlobalSpeedInvalidated, CurrentStateInvalidated, CurrentTimeInvalidated et RemoveRequested semblent être associés à la chronologie, s’inscrire à ces événements associe réellement un gestionnaire d’événements avec le Clock créé pour celle-ci.

Lorsque vous inscrivez l’événement Completed sur une chronologie, par exemple, vous indiquez au système de s’inscrire à l’événement Completed de chaque horloge créée pour la chronologie. Vous devez vous inscrire à cet événement dans le code avant que Clock ne soit créé pour cette chronologie; autrement, 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 Clock.

Voir aussi

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