Esporta (0) Stampa
Espandi tutto

Classe SplinePointKeyFrame

Aggiornamento: novembre 2007

Aggiunge un'animazione dal valore di Point del fotogramma chiave precedente fino al proprio oggetto Value utilizzando l'interpolazione spline.

Spazio dei nomi:  System.Windows.Media.Animation
Assembly:  PresentationCore (in PresentationCore.dll)
XMLNS per XAML: http://schemas.microsoft.com/winfx/xaml/presentation

public class SplinePointKeyFrame : PointKeyFrame
public class SplinePointKeyFrame extends PointKeyFrame
public class SplinePointKeyFrame extends PointKeyFrame

Questa classe viene utilizzata come parte di PointKeyFrameCollection in combinazione con PointAnimationUsingKeyFrames per aggiungere un'animazione a un valore della proprietà Point in un set di fotogrammi chiave.

Un fotogramma chiave definisce un segmento di PointAnimationUsingKeyFrames al quale appartiene. Ogni fotogramma chiave dispone di Value di destinazione e di KeyTime. KeyTime specifica il momento in cui dovrebbe essere raggiunto l'oggetto Value del fotogramma chiave. Un fotogramma chiave aggiunge un'animazione dal valore di destinazione del fotogramma chiave precedente al proprio valore di destinazione. Ha inizio quando termina il fotogramma chiave precedente e termina quando viene raggiunta la chiave temporale.

I fotogrammi chiave della spline come SplinePointKeyFrame creano una transizione variabile tra valori determinata dalla proprietà KeySpline. L'interpolazione spline può essere utilizzata per realizzare effetti realistici in termini di tempo, ad esempio, accelerazione e decelerazione.

In questo esempio viene illustrato come utilizzare la classe PointAnimationUsingKeyFrames per animare un oggetto Point.

Nell'esempio seguente viene spostata un'ellisse lungo un percorso triangolare. Viene utilizzata la classe PointAnimationUsingKeyFrames per animare la proprietà Center di un oggetto EllipseGeometry. In questa animazione vengono utilizzati tre fotogrammi chiave nel modo seguente:

  1. Durante il primo mezzo secondo, viene utilizzata un'istanza della classe LinearPointKeyFrame per spostare l'ellisse lungo un percorso a una velocità costante dalla posizione iniziale. I fotogrammi chiave lineari come LinearPointKeyFrame creano un'interpolazione lineare uniforme tra valori.

  2. Durante la fine del mezzo secondo successivo, viene utilizzata un'istanza della classe DiscretePointKeyFrame per spostare rapidamente l'ellisse lungo il percorso alla posizione successiva. I fotogrammi chiave discreti come DiscretePointKeyFrame creano salti improvvisi tra valori.

  3. Durante i due secondi finali, viene utilizzata un'istanza della classe SplinePointKeyFrame per riportare l'ellisse nella posizione iniziale. I fotogrammi chiave Spline come SplinePointKeyFrame creano una transizione variabile tra i valori a seconda dei valori della proprietà KeySpline. In questo esempio l'animazione inizia lentamente e aumenta di velocità in modo esponenziale verso la fine dell'intervallo di tempo.

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 PointAnimationUsingKeyFrames class
    /// to animate the position of an object.
    /// </summary>
    public class PointAnimationUsingKeyFramesExample : Page
    {
        public PointAnimationUsingKeyFramesExample()
        {
            Title = "PointAnimationUsingKeyFrames 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 an EllipseGeometry.
            EllipseGeometry myAnimatedEllipseGeometry =
                new EllipseGeometry(new Point(200,100), 15, 15);

            // Assign the EllipseGeometry a name so that
            // it can be targeted by a Storyboard.
            this.RegisterName(
                "MyAnimatedEllipseGeometry", myAnimatedEllipseGeometry);

            // Create a Path element to display the geometry.
            Path aPath = new Path();   
            aPath.Fill = Brushes.Blue;
            aPath.Data = myAnimatedEllipseGeometry;

            // Create a Canvas to contain the path.
            Canvas containerCanvas = new Canvas();
            containerCanvas.Width = 500;
            containerCanvas.Height = 400;
            containerCanvas.Children.Add(aPath);

            // Create a PointAnimationUsingKeyFrames to
            // animate the EllipseGeometry.
            PointAnimationUsingKeyFrames centerPointAnimation
                = new PointAnimationUsingKeyFrames();
            centerPointAnimation.Duration = TimeSpan.FromSeconds(5);

            // Animate from the starting position to (100,300)
            // over the first half-second using linear
            // interpolation.
            centerPointAnimation.KeyFrames.Add(
                new LinearPointKeyFrame(
                    new Point(100, 300), // Target value (KeyValue)
                    KeyTime.FromTimeSpan(TimeSpan.FromSeconds(0.5))) // KeyTime
                );

            // Animate from (100,300) (the value of the previous key frame) 
            // to (400,300) at 1 second using discrete interpolation.
            // Because the interpolation is discrete, the ellipse will appear
            // to "jump" to (400,300) at 1 second.
            centerPointAnimation.KeyFrames.Add(
                new DiscretePointKeyFrame(
                    new Point(400, 300), // Target value (KeyValue)
                    KeyTime.FromTimeSpan(TimeSpan.FromSeconds(1))) // KeyTime
                );

            // Animate from (400,300) (the value of the previous key frame) to (200,100)
            // over two seconds, starting at 1 second (the key time of the
            // last key frame) and ending at 3 seconds.
            centerPointAnimation.KeyFrames.Add(
                new SplinePointKeyFrame(
                    new Point(200, 100), // Target value (KeyValue)
                    KeyTime.FromTimeSpan(TimeSpan.FromSeconds(3)), // KeyTime
                    new KeySpline(0.6, 0.0, 0.9, 0.0) // KeySpline
                    )
                );

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

            // Set the animation to target the Center property
            // of the object named "MyAnimatedEllipseGeometry".
            Storyboard.SetTargetName(centerPointAnimation, "MyAnimatedEllipseGeometry");
            Storyboard.SetTargetProperty(
                centerPointAnimation, new PropertyPath(EllipseGeometry.CenterProperty));

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

            // Start the storyboard when the Path loads.
            aPath.Loaded += delegate(object sender, RoutedEventArgs e)
            {
                ellipseStoryboard.Begin(this);
            };

            Content = containerCanvas;
        }

    }
}


<Page 
  xmlns="http://schemas.microsoft.com/winfx/2006/xaml/presentation" 
  xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml"
  Background="White" Margin="20">
  <Canvas Width="400" Height="400">
    <Path Fill="Blue">
      <Path.Data>

        <!-- Describes an ellipse. -->
        <EllipseGeometry x:Name="MyAnimatedEllipseGeometry"
          Center="200,100" RadiusX="15" RadiusY="15" />
      </Path.Data>
      <Path.Triggers>
        <EventTrigger RoutedEvent="Path.Loaded">
          <BeginStoryboard>
            <Storyboard>

              <!-- Animating the Center property uses 3 KeyFrames, which animate
                   the ellipse allong a triangular path. -->
              <PointAnimationUsingKeyFrames
                Storyboard.TargetProperty="Center"
                Storyboard.TargetName="MyAnimatedEllipseGeometry"
                Duration="0:0:5" RepeatBehavior="Forever">

                <!-- Over the first half second, Using a LinearPointKeyFrame, the ellipse 
                     moves steadily from its starting position along the first line of the 
                     trianglar path.  -->
                <LinearPointKeyFrame 
                  KeyTime="0:0:0.5"
                  Value="100,300" />

                <!-- Using a DiscretePointKeyFrame, the ellipse suddenly changes position
                     after the first second of the animation. -->
                <DiscretePointKeyFrame 
                  KeyTime="0:0:1"
                  Value="400,300" />

                <!-- Using a SplinePointKeyFrame, the ellipse moves back to its starting
                     position. It moves slowly at first and then speeds up. This key frame 
                     takes 2 seconds to complete. -->
                <SplinePointKeyFrame 
                  KeySpline="0.6,0.0 0.9,0.00" 
                  KeyTime="0:0:3"
                  Value="200,100" />
              </PointAnimationUsingKeyFrames>
            </Storyboard>
          </BeginStoryboard>
        </EventTrigger>
      </Path.Triggers>
    </Path>
  </Canvas>
</Page>


Per l'esempio completo, vedere Esempio di animazione con fotogrammi chiave.

Per coerenza con altri esempi di animazione, nelle versioni del codice di questo esempio viene utilizzato un oggetto Storyboard per applicare PointAnimationUsingKeyFrames. Tuttavia, quando si applica una sola animazione nel codice, è più semplice utilizzare il metodo BeginAnimation anziché un oggetto Storyboard. Per un esempio, vedere Procedura: animare una proprietà senza utilizzare uno storyboard.

Qualsiasi membro static (Shared in Visual Basic) pubblico di questo tipo è thread-safe. I membri di istanza non sono garantiti come thread-safe.

Windows Vista

.NET Framework e .NET Compact Framework non supportano tutte le versioni di ciascuna piattaforma. Per un elenco delle versioni supportate, vedere Requisiti di sistema di .NET Framework.

.NET Framework

Supportato in: 3.5, 3.0

Aggiunte alla community

AGGIUNGI
Mostra:
© 2015 Microsoft