War diese Seite hilfreich?
Ihr Feedback ist uns wichtig. Teilen Sie uns Ihre Meinung mit.
Weiteres Feedback?
1500 verbleibende Zeichen
RectAnimationUsingKeyFrames-Klasse
Collapse the table of content
Expand the table of content

RectAnimationUsingKeyFrames-Klasse

Aktualisiert: November 2007

Animiert den Wert einer Eigenschaft, die ein Rect für einen Satz von Keyframes akzeptiert.

Namespace:  System.Windows.Media.Animation
Assembly:  PresentationCore (in PresentationCore.dll)
XMLNS für XAML: http://schemas.microsoft.com/winfx/xaml/presentation

[ContentPropertyAttribute("KeyFrames")]
public class RectAnimationUsingKeyFrames : RectAnimationBase, 
	IKeyFrameAnimation, IAddChild
/** @attribute ContentPropertyAttribute("KeyFrames") */
public class RectAnimationUsingKeyFrames extends RectAnimationBase implements IKeyFrameAnimation, 
	IAddChild
public class RectAnimationUsingKeyFrames extends RectAnimationBase implements IKeyFrameAnimation, IAddChild
<RectAnimationUsingKeyFrames>
  KeyFrames
</RectAnimationUsingKeyFrames>

Die Zielwerte einer Keyframeanimation werden durch ihre KeyFrames-Eigenschaft definiert, die eine Auflistung von RectKeyFrame-Objekten enthält. Jeder RectKeyFrame definiert ein Segment der Animation mit dem eigenen Ziel-Value und der eigenen KeyTime. Die Ausführung der Animation erfolgt zu den angegebenen Schlüsselzeiten von einem Schlüsselwert zum nächsten Schlüsselwert.

Es gibt drei Typen von RectKeyFrame-Klassen, und zwar für jede unterstützte Interpolationsmethode einen Typ: LinearRectKeyFrame, DiscreteRectKeyFrame und SplineRectKeyFrame.

Im Gegensatz zu einer RectAnimation kann eine RectAnimationUsingKeyFrames über mehr als zwei Zielwerte verfügen. Sie können auch die Interpolationsmethode einzelner RectKeyFrame-Segmente steuern.

In diesem Beispiel wird die Animation der Rect-Eigenschaft eines RectangleGeometrys mithilfe von Keyframes veranschaulicht.

Im folgenden Beispiel wird die RectAnimationUsingKeyFrames-Klasse verwendet, um die Rect-Eigenschaft eines RectangleGeometry zu animieren. In dieser Animation werden drei Keyframes folgendermaßen verwendet:

  1. In den ersten zwei Sekunden wird die Instanz der LinearRectKeyFrame-Klasse verwendet, um Position, Breite und Höhe eines Rechtecks graduell zu ändern. Durch lineare Keyframes wie LinearRectKeyFrame wird ein glatter, linearer Übergang zwischen Werten ermöglicht.

  2. Am Ende der nächsten halben Sekunde wird die Instanz einer DiscreteRectKeyFrame-Klasse verwendet, um die Höhe des Rechtecks abrupt zu verringern. Diskrete Keyframes wie DiscreteRectKeyFrame ermöglichen abrupte Änderungen zwischen Werten, d.h. die Verringerung der Höhe tritt schnell und deutlich sichtbar ein.

  3. In den letzten zwei Sekunden wird eine Instanz der SplineRectKeyFrame-Klasse verwendet, um das Rechteck zurück auf seine Originalgröße und Ausgangsposition zu setzen. Spline-Keyframes wie SplineRectKeyFrame erzeugen einen variablen Übergang zwischen Werten, die von der KeySpline-Eigenschaft bestimmt werden. In diesem Beispiel beginnt die Veränderung zunächst langsam und beschleunigt dann exponentiell im letzten Bereich des Zeitabschnitts.

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 RectAnimationUsingKeyFrames class to
    /// animate the position and size of a rectangle.
    /// Key frame animations enable you to create complex animations 
    /// by specifying multiple destination values
    /// and controlling the animation's interpolation method.
    /// </summary>
    public class RectAnimationUsingKeyFramesExample : Page
    {
        public RectAnimationUsingKeyFramesExample()
        {
            Title = "RectAnimationUsingKeyFrames 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());

            StackPanel myStackPanel = new StackPanel();
            myStackPanel.Orientation = Orientation.Vertical;
            myStackPanel.HorizontalAlignment = HorizontalAlignment.Center;

            //Add the Path Element
            Path myPath = new Path();
            myPath.Stroke = Brushes.Black;
            myPath.Fill = Brushes.LemonChiffon;
            myPath.StrokeThickness = 1;

            // Create a RectangleGeometry to specify the Path data.
            RectangleGeometry myRectangleGeometry = new RectangleGeometry();
            myRectangleGeometry.Rect = new Rect(0, 200, 100, 100);
            myPath.Data = myRectangleGeometry;

            myStackPanel.Children.Add(myPath);

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

            // Create a RectAnimationUsingKeyFrames to
            // animate the RectangleGeometry.
            RectAnimationUsingKeyFrames rectAnimation 
                = new RectAnimationUsingKeyFrames();
            rectAnimation.Duration = TimeSpan.FromSeconds(6);

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

            // Animate position, width, and height in first 2 seconds. LinearRectKeyFrame creates
            // a smooth, linear animation between values.
            rectAnimation.KeyFrames.Add(
                new LinearRectKeyFrame(
                    new Rect(600,50,200,50), // Target value (KeyValue)
                    KeyTime.FromTimeSpan(TimeSpan.FromSeconds(2))) // KeyTime
                );

            // In the next half second, change height to 10. DiscreteRectKeyFrame creates a 
            // sudden "jump" between values.
            rectAnimation.KeyFrames.Add(
                new DiscreteRectKeyFrame(
                    new Rect(600, 50, 200, 10), // Target value (KeyValue)
                    KeyTime.FromTimeSpan(TimeSpan.FromSeconds(2.5))) // KeyTime
                );

            // In the final 2 seconds of the animation, go back to the starting position, width, and height.  
            // Spline key frames like SplineRectKeyFrame creates a variable transition between values depending 
            // on the KeySpline property. In this example, the animation starts off slow but toward the end of 
            // the time segment, it speeds up exponentially.
            rectAnimation.KeyFrames.Add(
                new SplineRectKeyFrame(
                    new Rect(0, 200, 100, 100), // Target value (KeyValue)
                    KeyTime.FromTimeSpan(TimeSpan.FromSeconds(4.5)), // KeyTime
                    new KeySpline(0.6, 0.0, 0.9, 0.0) // KeySpline
                    )
                );

            // Set the animation to target the Rect property
            // of the object named "AnimatedRectangleGeometry."
            Storyboard.SetTargetName(rectAnimation, "AnimatedRectangleGeometry");
            Storyboard.SetTargetProperty(
                rectAnimation, new PropertyPath(RectangleGeometry.RectProperty));

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

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

            Content = myStackPanel;
        }

    }
}


<Page  
  xmlns="http://schemas.microsoft.com/winfx/2006/xaml/presentation"
  xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml"
  Title="ThicknessAnimationUsingKeyFrames Example">

  <StackPanel Orientation="Vertical" HorizontalAlignment="Center">

    <Path Stroke="Black" StrokeThickness="1" Fill="LemonChiffon">
      <Path.Data>
        <RectangleGeometry x:Name="myRectangleGeometry" Rect="0,200,100,100" />
      </Path.Data>
      <Path.Triggers>
        <EventTrigger RoutedEvent="Path.Loaded">
          <BeginStoryboard>
            <Storyboard>

              <!-- Animate the Rect property of the RectangleGeometry which causes the
              rectangle to animate its position as well as its width and height. -->
              <RectAnimationUsingKeyFrames
                Storyboard.TargetName="myRectangleGeometry"
                Storyboard.TargetProperty ="Rect"
                Duration="0:0:6" FillBehavior="HoldEnd" RepeatBehavior="Forever">

                <!-- Animate position, width, and height in first 2 seconds. LinearRectKeyFrame creates
                a smooth, linear animation between values. -->
                <LinearRectKeyFrame Value="600,50,200,50" KeyTime="0:0:2" />

                <!-- In the next half second, change height to 10. DiscreteRectKeyFrame creates a 
                sudden "jump" between values. -->
                <DiscreteRectKeyFrame Value="600,50,200,10" KeyTime="0:0:2.5" />

                <!-- In the final 2 seconds of the animation, go back to the starting position, width, and height.  
                Spline key frames like SplineRectKeyFrame creates a variable transition between values depending 
                on the KeySpline property. In this example, the animation starts off slow but toward the end of 
                the time segment, it speeds up exponentially.-->
                <SplineRectKeyFrame Value="0,200,100,100" KeyTime="0:0:4.5" KeySpline="0.6,0.0 0.9,0.00"  />
              </RectAnimationUsingKeyFrames>
            </Storyboard>
          </BeginStoryboard>
        </EventTrigger>
      </Path.Triggers>
    </Path>

  </StackPanel>
</Page>


Das vollständige Beispiel finden Sie unter Beispiel für eine Keyframe-Animation.

Alle öffentlichen static (Shared in Visual Basic)-Member dieses Typs sind threadsicher. Bei Instanzmembern ist die Threadsicherheit nicht gewährleistet.

Windows Vista

.NET Framework und .NET Compact Framework unterstützen nicht alle Versionen sämtlicher Plattformen. Eine Liste der unterstützten Versionen finden Sie unter Systemanforderungen für .NET Framework.

.NET Framework

Unterstützt in: 3.5, 3.0

Community-Beiträge

HINZUFÜGEN
Microsoft führt eine Onlineumfrage durch, um Ihre Meinung zur MSDN-Website zu erfahren. Wenn Sie sich zur Teilnahme entscheiden, wird Ihnen die Onlineumfrage angezeigt, sobald Sie die MSDN-Website verlassen.

Möchten Sie an der Umfrage teilnehmen?
Anzeigen:
© 2015 Microsoft