Exporter (0) Imprimer
Développer tout

SplineByteKeyFrame, classe

Mise à jour : novembre 2007

Passe de la valeur Byte correspondant à la précédente image clé à sa propre valeur Value en utilisant une opération d'interpolation spline.

Espace de noms :  System.Windows.Media.Animation
Assembly :  PresentationCore (dans PresentationCore.dll)
XMLNS pour XAML : http://schemas.microsoft.com/winfx/xaml/presentation

public class SplineByteKeyFrame : ByteKeyFrame
public class SplineByteKeyFrame extends ByteKeyFrame
public class SplineByteKeyFrame extends ByteKeyFrame

Cette classe est utilisée dans le cadre de la collection ByteKeyFrameCollection avec un ByteAnimationUsingKeyFrames afin d'animer une valeur de la propriété Byte en fonction d'un ensemble d'images clés.

Une image clé définit un segment du ByteAnimationUsingKeyFrames auquel elle appartient. Une valeur Value cible et une période de clé KeyTime sont définies pour chaque image clé. Le KeyTime spécifie l'heure à laquelle la valeur Value de l'image clé doit être atteinte. Une image clé passe de la valeur cible de l'image clé précédente à sa propre valeur cible. Elle démarre à la fin de l'image clé précédente et s'achève au terme de sa propre période de clé.

Les images clé de spline telles que SplineByteKeyFrame permettent d'assurer une transition à paramètres variables entre les valeurs, transition déterminée par la propriété KeySpline. L'interpolation spline peut être utilisée pour obtenir des effets de minutage, tels que des effets d'accélération et de décélération, plus proches de la réalité.

Cet exemple montre comment animer la valeur d'une propriété qui accepte un Double en utilisant des images clés.

L'exemple suivant déplace un rectangle sur un écran. L'exemple utilise la classe DoubleAnimationUsingKeyFrames pour animer la propriété X d'un TranslateTransform appliqué à un Rectangle. Cette animation, répétée indéfiniment, utilise trois images clés de la manière suivante :

  1. Pendant les trois premières secondes, utilise une instance de la classe LinearDoubleKeyFrame pour déplacer le rectangle le long d'un tracé, à une vitesse constante, de sa position de départ à la position 500. Les images clés linéaires telles que LinearDoubleKeyFrame créent une transition linéaire fluide entre les valeurs.

  2. Au bout de la quatrième seconde, utilise une instance de la classe DiscreteDoubleKeyFrame pour déplacer soudainement le rectangle à la position suivante. Les images clés discrètes comme DiscreteDoubleKeyFrame créent des sauts soudains entre les valeurs. Dans cet exemple, le rectangle est à la position de départ, puis apparaît soudainement à la position 500.

  3. Durant les deux dernières secondes, utilise une instance de la classe SplineDoubleKeyFrame pour ramener le rectangle à sa position de départ. Des images clé spline comme SplineDoubleKeyFrame créent une transition variable entre des valeurs en fonction de la valeur de la propriété KeySpline. Dans cet exemple, le rectangle commence par se déplacer lentement, puis accélère de façon exponentielle vers la fin du segment temporel.

using System;
using System.Windows;
using System.Windows.Controls;
using System.Windows.Shapes;
using System.Windows.Media.Animation;
using System.Windows.Media;

namespace Microsoft.Samples.KeyFrameExamples
{
    /// <summary>
    /// This example shows how to use the DoubleAnimationUsingKeyFrames class to
    /// animate the position of an object.
    /// Key frame animations enable you to create complex animations 
    /// by specifying multiple destination values
    /// and controlling the animation's interpolation method.
    /// </summary>
    public class AltDoubleAnimationUsingKeyFramesExample : Page
    {
        public AltDoubleAnimationUsingKeyFramesExample()
        {
            Title = "DoubleAnimationUsingKeyFrames Example";
            Background = Brushes.White;
            Margin = new Thickness(20);

            // Create a NameScope for this page so that
            // Storyboards can be used.
            NameScope.SetNameScope(this, new NameScope());

            // Create a rectangle.
            Rectangle aRectangle = new Rectangle();
            aRectangle.Width = 100;
            aRectangle.Height = 100;
            aRectangle.Stroke = Brushes.Black;
            aRectangle.StrokeThickness = 5;

            // Create a Canvas to contain and
            // position the rectangle.
            Canvas containerCanvas = new Canvas();
            containerCanvas.Width = 610;
            containerCanvas.Height = 300;
            containerCanvas.Children.Add(aRectangle);
            Canvas.SetTop(aRectangle, 100);
            Canvas.SetLeft(aRectangle, 10);         

            // Create a TranslateTransform to 
            // move the rectangle.
            TranslateTransform animatedTranslateTransform = 
                new TranslateTransform();
            aRectangle.RenderTransform = animatedTranslateTransform;  

            // Assign the TranslateTransform a name so that
            // it can be targeted by a Storyboard.
            this.RegisterName(
                "AnimatedTranslateTransform", animatedTranslateTransform);

            // Create a DoubleAnimationUsingKeyFrames to
            // animate the TranslateTransform.
            DoubleAnimationUsingKeyFrames translationAnimation 
                = new DoubleAnimationUsingKeyFrames();
            translationAnimation.Duration = TimeSpan.FromSeconds(6);

            // Animate from the starting position to 500
            // over the first second using linear
            // interpolation.
            translationAnimation.KeyFrames.Add(
                new LinearDoubleKeyFrame(
                    500, // Target value (KeyValue)
                    KeyTime.FromTimeSpan(TimeSpan.FromSeconds(3))) // KeyTime
                );

            // Animate from 500 (the value of the previous key frame) 
            // to 400 at 4 seconds using discrete interpolation.
            // Because the interpolation is discrete, the rectangle will appear
            // to "jump" from 500 to 400.
            translationAnimation.KeyFrames.Add(
                new DiscreteDoubleKeyFrame(
                    400, // Target value (KeyValue)
                    KeyTime.FromTimeSpan(TimeSpan.FromSeconds(4))) // KeyTime
                );

            // Animate from 400 (the value of the previous key frame) to 0
            // over two seconds, starting at 4 seconds (the key time of the
            // last key frame) and ending at 6 seconds.
            translationAnimation.KeyFrames.Add(
                new SplineDoubleKeyFrame(
                    0, // Target value (KeyValue)
                    KeyTime.FromTimeSpan(TimeSpan.FromSeconds(6)), // KeyTime
                    new KeySpline(0.6,0.0,0.9,0.0) // KeySpline
                    )
                );

            // Set the animation to repeat forever. 
            translationAnimation.RepeatBehavior = RepeatBehavior.Forever;

            // Set the animation to target the X property
            // of the object named "AnimatedTranslateTransform."
            Storyboard.SetTargetName(translationAnimation, "AnimatedTranslateTransform");
            Storyboard.SetTargetProperty(
                translationAnimation, new PropertyPath(TranslateTransform.XProperty));

            // Create a storyboard to apply the animation.
            Storyboard translationStoryboard = new Storyboard();
            translationStoryboard.Children.Add(translationAnimation);

            // Start the storyboard after the rectangle loads.
            aRectangle.Loaded += delegate(object sender, RoutedEventArgs e)
            {
                translationStoryboard.Begin(this);
            };

            Content = containerCanvas;
        }

    }
}


<!-- This example shows how to use the DoubleAnimationUsingKeyFrames to 
     animate the position of an object. 
     Key frame animations enable you to create complex animations 
     by specifying multiple destination values
     and controlling the animation's interpolation method.
-->
<Page 
  xmlns="http://schemas.microsoft.com/winfx/2006/xaml/presentation"
  xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml"
  Title="DoubleAnimationUsingKeyFrames Example"
  Background="White" Margin="20">       
  <Canvas Width="610" Height="300">

    <!-- The position of this rectangle is animated using 
         a key frame animation. -->
    <Rectangle 
      Canvas.Top="100"
      Canvas.Left="10"
      Height="100"
      Width="100"
      Stroke="Black"
      StrokeThickness="5">
      <Rectangle.RenderTransform>
        <TranslateTransform x:Name="AnimatedTranslateTransform" />
      </Rectangle.RenderTransform>

      <Rectangle.Triggers>
        <EventTrigger RoutedEvent="Rectangle.Loaded">
          <BeginStoryboard>
            <Storyboard>

              <!-- Animate the TranslateTransform.X property using 3 KeyFrames
                   which animates the rectangle along a straight line. 
                   This animation repeats indefinitely. -->
              <DoubleAnimationUsingKeyFrames
                Storyboard.TargetName="AnimatedTranslateTransform"
                Storyboard.TargetProperty="X"
                Duration="0:0:6"
                RepeatBehavior="Forever">

                <!-- Using a LinearDoubleKeyFrame, the rectangle moves 
                     steadily from its starting position to 500 over 
                     the first 3 seconds.  -->
                <LinearDoubleKeyFrame Value="500" KeyTime="0:0:3" />

                <!-- Using a DiscreteDoubleKeyFrame, the rectangle suddenly 
                     appears at 400 after the fourth second of the animation. -->
                <DiscreteDoubleKeyFrame Value="400" KeyTime="0:0:4" />

                <!-- Using a SplineDoubleKeyFrame, the rectangle moves 
                     back to its starting point. The
                     animation starts out slowly at first and then speeds up. 
                     This KeyFrame ends after the 6th
                     second. -->
                <SplineDoubleKeyFrame KeySpline="0.6,0.0 0.9,0.00" Value="0" KeyTime="0:0:6" />
              </DoubleAnimationUsingKeyFrames>
            </Storyboard>
          </BeginStoryboard>
        </EventTrigger>
      </Rectangle.Triggers>
    </Rectangle>
  </Canvas>
</Page>


Pour l'exemple complet, consultez Animation d'image clé, exemple.

Pour des raisons de cohérence avec d'autres exemples d'animation, les versions de code de cet exemple utilisent un objet Storyboard pour appliquer DoubleAnimationUsingKeyFrames. Autrement, lors de l'application d'une seule animation dans le code, il est plus simple d'utiliser la méthode BeginAnimation qu'un Storyboard. Pour obtenir un exemple, consultez Comment : animer une propriété sans utiliser de table de montage séquentiel.

Tous les membres static (Shared en Visual Basic) publics de ce type sont thread-safe. Il n'est pas garanti que les membres d'instance soient thread-safe.

Windows Vista

Le .NET Framework et le .NET Compact Framework ne prennent pas en charge toutes les versions de chaque plateforme. Pour obtenir la liste des versions prises en charge, consultez Configuration requise du .NET Framework.

.NET Framework

Pris en charge dans : 3.5, 3.0

Ajouts de la communauté

AJOUTER
Afficher:
© 2014 Microsoft