Storyboard, classe
TOC
Réduire la table des matières
Développer la table des matières

Storyboard Class

Contrôle les animations dans une chronologie et fournit des informations de ciblage sur l'objet et la propriété pour ses animations enfants.

Héritage

Object
  DependencyObject
    Timeline
      Storyboard

Syntaxe


public sealed class Storyboard : Timeline


<Storyboard ...>
  oneOrMoreChildTimelines
</Storyboard>

XAML Values

oneOrMoreChildTimelines

Un ou plusieurs éléments objet pour les classes dérivées de la Timeline. Il peut s'agir d'un autre Storyboard ou de plusieurs types d'animations.

Attributs

[ContentProperty("Name=Children")]
[MarshalingBehavior(Agile)]
[Threading(Both)]
[Version(0x06020000)]
[WebHostHidden()]

Membres

StoryboardClasse possède ces types de membres :

Constructeurs

StoryboardClasse possède ces constructeurs.

ConstructeurDescription
Storyboard Initializes a new instance of the Storyboard class.

 

Événements

StoryboardClasse possède ces événements.

ÉvénementDescription
Completed Occurs when the Storyboard object has completed playing. (Hérité de Timeline)

 

Méthodes

The Storyboard Classe a les méthodes suivantes. Elle hérite également des méthodes de Object Classe.

MéthodeDescription
Begin Initiates the set of animations associated with the storyboard.
ClearValue Clears the local value of a dependency property. (Hérité de DependencyObject)
GetAnimationBaseValue Returns any base value established for a dependency property, which would apply in cases where an animation is not active. (Hérité de DependencyObject)
GetCurrentState Gets the clock state of the Storyboard.
GetCurrentTime Gets the current animation clock time of the Storyboard.
GetTargetName Gets the value of the Storyboard.TargetName XAML attached property from a target element.
GetTargetProperty Gets the value of the Storyboard.TargetProperty XAML attached property from a target element.
GetValue Returns the current effective value of a dependency property from a DependencyObject. (Hérité de DependencyObject)
Pause Pauses the animation clock associated with the storyboard.
ReadLocalValue Returns the local value of a dependency property, if a local value is set. (Hérité de DependencyObject)
Resume Resumes the animation clock, or run-time state, associated with the storyboard.
Seek Moves the storyboard to the specified animation position. The storyboard performs the requested seek when the next clock tick occurs.
SeekAlignedToLastTick Moves the storyboard to the specified animation position immediately (synchronously).
SetTarget Causes the specified Timeline to target the specified object.
SetTargetName Sets the value of the Storyboard.TargetName XAML attached property for a target element.
SetTargetProperty Sets the value of the Storyboard.TargetProperty XAML attached property for a target element.
SetValue Sets the local value of a dependency property on a DependencyObject. (Hérité de DependencyObject)
SkipToFill Advances the current time of the storyboard's clock to the end of its active period.
Stop Stops the storyboard.

 

Propriétés jointes

Le StoryboardClasse has these attached properties.

Type d'accèsDescription

Storyboard.TargetName

Lecture/écritureGets or sets the name of the object to animate.

Storyboard.TargetProperty

Lecture/écritureGets or sets the property that should be animated.

 

Propriétés

Le StoryboardClasse a les propriétés suivantes.

PropriétéType d'accèsDescription

AutoReverse

Lecture/écritureGets or sets a value that indicates whether the timeline plays in reverse after it completes a forward iteration. (Hérité de Timeline)

BeginTime

Lecture/écritureGets or sets the time at which this Timeline should begin. (Hérité de Timeline)

Children

En lecture seuleGets the collection of child Timeline objects.

Dispatcher

En lecture seuleGets the CoreDispatcher that this object is associated with. (Hérité de DependencyObject)

Duration

Lecture/écritureGets or sets the length of time for which this timeline plays, not counting repetitions. (Hérité de Timeline)

FillBehavior

Lecture/écritureGets or sets a value that specifies how the animation behaves after it reaches the end of its active period. (Hérité de Timeline)

RepeatBehavior

Lecture/écritureGets or sets the repeating behavior of this timeline. (Hérité de Timeline)

SpeedRatio

Lecture/écritureGets or sets the rate, relative to its parent, at which time progresses for this Timeline. (Hérité de Timeline)

TargetNameProperty

En lecture seuleIdentifies the Storyboard.TargetName XAML attached property.

TargetPropertyProperty

En lecture seuleIdentifies the Storyboard.TargetProperty XAML attached property.

 

Remarques

Storyboard est une classe importante dans le concept des animations avec table de montage séquentiel. Pour plus d'informations sur le concept, consultez Animations avec plan conceptuel.

Storyboard est utilisé pour ces propriétés :

Ces propriétés ne sont pas le seul emplacement où un Storyboard est défini. La manière classique d'utiliser Storyboard pour une animation avec table de montage séquentiel est que Storyboard est défini dans une collection Resources (Application.Resources ou FrameworkElement.Resources, ou éventuellement en tant que ressource dans un fichier tel que StandardStyles.xaml). S'il est utilisé de cette manière, vous devez toujours assigner une valeur d'attribut x:Name à votre Storyboard. Vous pouvez ensuite référencer le nom en tant que variable de programmation ultérieurement dans le fichier code-behind. Vous aurez besoin de cette référence pour exécuter réellement les animations contenues par Storyboard, en appelant la méthode Begin sur cette instance Storyboard. Storyboard a également d'autres méthodes de contrôle.

Storyboard hérite de plusieurs propriétés de Timeline. Ces propriétés peuvent être appliquées soit à un Storyboard ou à une des animations qui s'y trouvent (dans la collection Children ). La définition des propriétés Timeline sur le principal Storyboard plutôt que sur chacune des animations, présente des avantages et des inconvénients. Pour plus d'informations, consultez Animations avec plan conceptuel.

Vous avez également besoin de Storyboard pour contrôler les animations de personnalité que vous ajoutez aux contrôles ou à l'interface utilisateur, si vous utilisez l'une des animations de thème. Les animations de thème n'ont pas de point de déclenchement inné ; vous devez donc regrouper les animations de thème dans un Storyboard comme Children, puis appeler Begin dans la logique de votre application lorsque vous gérez des déclencheurs d'événements pour chaque type d'animation de thème. Pour plus d'informations, consultez Démarrage rapide : animation de votre interface utilisateur.

Propriétés jointes XAML du plan conceptuel

Storyboard est la classe de service hôte de plusieurs propriétés jointes XAML. Elles activent les animations enfants sous le contrôle de Storyboard pour les éléments cibles distincts et propriétés cibles de chaque cible tout en suivant la même chronologie de contrôle et le même mécanisme de déclenchement que pour le parent.

Les propriétés jointes XAML qui sont prises en charge par Storyboard sont les suivantes :

Storyboard.TargetName est utilisé pour référencer un autre élément par son nom. L'élément référencé est l'élément/l'objet où l'animation doit s'appliquer. Ce mécanisme fait partie de la conception de base du système d'animation : il permet aux ressources d'animation d'être déclarées séparément des ressources de déclaration d'interface utilisateur, et autorise le recentrage de l'animation. Pour la valeur de Storyboard.TargetName sur une animation particulière, vous spécifiez la valeur d'attribut Name ou X:Name de l'élément cible, qui est une chaîne. Cet élément nommé doit déjà exister dans un autre domaine de balisage XAML.

Storyboard.TargetProperty cible une propriété particulière de l'élément tel qu'il est nommé par Storyboard.TargetName. La valeur que vous fournissez pour Storyboard.TargetProperty implique un concept appelé chemin de propriété. Pour plus d'informations sur la manière de spécifier un chemin de propriété pour une animation, consultez les notes dans la rubrique SetTargetProperty ou Storyboard.TargetProperty ou Syntaxe de PropertyPath.

Pour prendre en charge l'accès du processeur XAML aux propriétés jointes et pour exposer les opérations Get et Set équivalentes au code, chaque propriété jointe XAML possède une paire de méthodes d'accesseur Get et Set. Par exemple, les méthodes GetTargetName et SetTargetName prennent en charge et fournissent la prise en charge du code équivalent pour Storyboard.TargetName. Ou alors, vous pouvez utiliser le système de propriétés de dépendance pour obtenir ou définir la valeur de la propriété attachée. Appelez GetValue ou SetValue en passant les arguments de l'identificateur de la propriété de dépendance à définir et une référence à l'objet cible sur lequel obtenir ou définir la valeur.

Exemples

L'exemple suivant montre comment utiliser les méthodes Begin, Stop, Pause et Resume pour contrôler la lecture d'un plan conceptuel (animation). Un jeu de boutons permet à l'utilisateur d'appeler ces méthodes.


<StackPanel x:Name="LayoutRoot" >
    <StackPanel.Resources>
        <Storyboard x:Name="myStoryboard">
            <DoubleAnimation From="1" To="6" Duration="00:00:6" 
            Storyboard.TargetName="rectScaleTransform" 
            Storyboard.TargetProperty="ScaleY">
                <DoubleAnimation.EasingFunction>
                    <BounceEase Bounces="2" EasingMode="EaseOut" 
                            Bounciness="2" />
                </DoubleAnimation.EasingFunction>
            </DoubleAnimation>
        </Storyboard>
    </StackPanel.Resources>

    <!-- Button that begins animation. -->
    <Button Click="Animation_Begin"
         Margin="2" Content="Begin" />

    <!-- Button that pauses Animation. -->
    <Button Click="Animation_Pause"
         Margin="2" Content="Pause" />

    <!-- Button that resumes Animation. -->
    <Button Click="Animation_Resume"
         Margin="2" Content="Resume" />

    <!-- Button that stops Animation. Stopping the animation 
         returns the ellipse to its original location. -->
    <Button Click="Animation_Stop"
         Margin="2" Content="Stop" />

    <Rectangle Fill="Blue" Width="200" Height="30">
        <Rectangle.RenderTransform>
            <ScaleTransform x:Name="rectScaleTransform" />
        </Rectangle.RenderTransform>
    </Rectangle>

</StackPanel>



private void Animation_Begin(object sender, RoutedEventArgs e)
{
    myStoryboard.Begin();
}
private void Animation_Pause(object sender, RoutedEventArgs e)
{
    myStoryboard.Pause();
}
private void Animation_Resume(object sender, RoutedEventArgs e)
{
    myStoryboard.Resume();
}
private void Animation_Stop(object sender, RoutedEventArgs e)
{
    myStoryboard.Stop();
}


L'exemple suivant montre comment créer un Storyboard à l'aide du code.


//using Windows.UI.Xaml.Media.Animation;
//using Windows.UI.Xaml.Shapes;

private void Create_And_Run_Animation(object sender, RoutedEventArgs e)
{
    // Create a red rectangle that will be the target
    // of the animation.
    Rectangle myRectangle = new Rectangle();
    myRectangle.Width = 200;
    myRectangle.Height = 200;
    Windows.UI.Color myColor = Windows.UI.Color.FromArgb(255, 255, 0, 0);
    SolidColorBrush myBrush = new SolidColorBrush();
    myBrush.Color = myColor;
    myRectangle.Fill = myBrush;

    // Create the transform
    TranslateTransform moveTransform = new TranslateTransform();
    moveTransform.X = 0;
    moveTransform.Y = 0;

    myRectangle.RenderTransform = moveTransform;


    // Add the rectangle to the tree.
    LayoutRoot.Children.Add(myRectangle);

    // Create a duration of 2 seconds.
    Duration duration = new Duration(TimeSpan.FromSeconds(2));

    // Create two DoubleAnimations and set their properties.
    DoubleAnimation myDoubleAnimationX = new DoubleAnimation();
    DoubleAnimation myDoubleAnimationY = new DoubleAnimation();

    myDoubleAnimationX.Duration = duration;
    myDoubleAnimationY.Duration = duration;

    Storyboard justintimeStoryboard = new Storyboard();
    justintimeStoryboard.Duration = duration;

    justintimeStoryboard.Children.Add(myDoubleAnimationX);
    justintimeStoryboard.Children.Add(myDoubleAnimationY);

    Storyboard.SetTarget(myDoubleAnimationX, moveTransform);
    Storyboard.SetTarget(myDoubleAnimationY, moveTransform);

    // Set the X and Y properties of the Transform to be the target properties
    // of the two respective DoubleAnimations.
    Storyboard.SetTargetProperty(myDoubleAnimationX, "X");
    Storyboard.SetTargetProperty(myDoubleAnimationY, "Y");

    myDoubleAnimationX.To = 200;
    myDoubleAnimationY.To = 200;

    // Make the Storyboard a resource.
    LayoutRoot.Resources.Add("justintimeStoryboard", justintimeStoryboard);

    // Begin the animation.
    justintimeStoryboard.Begin();
}


Conditions requises

Client minimal pris en charge

Windows 8 [Applications Windows Store uniquement]

Serveur minimal pris en charge

Windows Server 2012 [Applications Windows Store uniquement]

Espace de noms

Windows.UI.Xaml.Media.Animation
Windows::UI::Xaml::Media::Animation [C++]

Métadonnées

Windows.winmd

Voir aussi

Timeline
Démarrage rapide : animation de votre interface utilisateur
Animations d'image clé et animations de fonctions d'accélération
Syntaxe de chemin d'accès de propriété
Animations avec table de montage séquentiel
Animations avec plan conceptuel pour les états visuels
Vue d'ensemble des propriétés jointes
PropertyPath, syntaxe

 

 

Afficher:
© 2017 Microsoft