Storyboard Classe

Definizione

Spazio dei nomi:

Windows.UI.Xaml.Media.Animation

Controlla le animazioni con una sequenza temporale e fornisce informazioni di destinazione dell'oggetto e delle proprietà per le animazioni figlio.

public ref class Storyboard sealed : Timeline

/// [Windows.Foundation.Metadata.ContractVersion(Windows.Foundation.UniversalApiContract, 65536)]
/// [Windows.Foundation.Metadata.MarshalingBehavior(Windows.Foundation.Metadata.MarshalingType.Agile)]
/// [Windows.Foundation.Metadata.Threading(Windows.Foundation.Metadata.ThreadingModel.Both)]
/// [Windows.UI.Xaml.Markup.ContentProperty(Name="Children")]
/// [Windows.Foundation.Metadata.Activatable(65536, "Windows.Foundation.UniversalApiContract")]
class Storyboard final : Timeline

[Windows.Foundation.Metadata.ContractVersion(typeof(Windows.Foundation.UniversalApiContract), 65536)]
[Windows.Foundation.Metadata.MarshalingBehavior(Windows.Foundation.Metadata.MarshalingType.Agile)]
[Windows.Foundation.Metadata.Threading(Windows.Foundation.Metadata.ThreadingModel.Both)]
[Windows.UI.Xaml.Markup.ContentProperty(Name="Children")]
[Windows.Foundation.Metadata.Activatable(65536, "Windows.Foundation.UniversalApiContract")]
public sealed class Storyboard : Timeline

Public NotInheritable Class Storyboard
Inherits Timeline

<Storyboard ...>
  oneOrMoreChildTimelines
</Storyboard>

Ereditarietà

Object Platform::Object IInspectable DependencyObject Timeline Storyboard

Attributi

ActivatableAttribute ContractVersionAttribute MarshalingBehaviorAttribute ThreadingAttribute ContentPropertyAttribute

Requisiti Windows

Famiglia di dispositivi	Windows 10 (è stato introdotto in 10.0.10240.0)
API contract	Windows.Foundation.UniversalApiContract (è stato introdotto in v1.0)

Esempio

Nell'esempio seguente viene illustrato come usare i metodi Begin, Stop, Pause e Resume per controllare la riproduzione di uno storyboard (animazione). Un set di pulsanti consente all'utente di chiamare questi metodi.

<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();
}

Private Sub Animation_Begin(sender As Object, e As RoutedEventArgs)
    myStoryboard.Begin()
End Sub

Private Sub Animation_Pause(sender As Object, e As RoutedEventArgs)
    myStoryboard.Pause()
End Sub

Private Sub Animation_Resume(sender As Object, e As RoutedEventArgs)
    myStoryboard.Resume()
End Sub

Private Sub Animation_Stop(sender As Object, e As RoutedEventArgs)
    myStoryboard.Stop()
End Sub

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

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;
    SolidColorBrush myBrush = new SolidColorBrush(Colors.Red);
    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();
}

' need Imports for Windows.UI.Xaml.Shapes, Windows.UI.Media.Animation, Windows.UI
Private Sub Create_And_Run_Animation(sender As Object, e As RoutedEventArgs)
    ' Create a red rectangle that will be the target
    ' of the animation.
    Dim myRectangle As Rectangle = New Rectangle
    myRectangle.Width = 200
    myRectangle.Height = 200
    Dim myBrush As SolidColorBrush = New SolidColorBrush(Colors.Red)
    myRectangle.Fill = myBrush

   ' Create the transform
    Dim moveTransform As TranslateTransform = 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.
    Dim duration As Duration = New Duration(TimeSpan.FromSeconds(2))
    ' Create two DoubleAnimations and set their properties.
    Dim myDoubleAnimationX As DoubleAnimation = New DoubleAnimation
    Dim myDoubleAnimationY As DoubleAnimation = New DoubleAnimation
    myDoubleAnimationX.Duration = duration
    myDoubleAnimationY.Duration = duration
    Dim justintimeStoryboard As Storyboard = 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()
End Sub

Commenti

Storyboard è una classe importante nel concetto di animazioni storyboard. Per altre informazioni sul concetto, vedere Animazioni storyboard.

Storyboard viene usato per queste proprietà:

• VisualState.Storyboard
• VisualTransition.Storyboard
• BeginStoryboard.Storyboard

Queste proprietà non sono l'unica posizione in cui è definito un Storyboard. Il modo tipico in cui viene usato uno Storyboard per un'animazione storyboard è che lo Storyboard è definito in un insieme Resources ( Application.Resources o FrameworkElement.Resources o eventualmente come risorsa all'interno di un file, ad esempio Generic.xaml per un controllo personalizzato). Ogni volta che viene definito come risorsa XAML, è sempre necessario assegnare un valore di attributo x:Name al storyboard. È quindi possibile fare riferimento al nome come variabile di programmazione più avanti nel code-behind. È necessario questo riferimento per eseguire effettivamente le animazioni contenute nello Storyboard chiamando il metodo Begin nell'istanza di Storyboard. Storyboard include anche altri metodi di controllo, ad esempio Stop , che possono controllare l'animazione successivamente.

Storyboard eredita diverse proprietà dalla sequenza temporale. Queste proprietà possono essere applicate a uno Storyboard o a una delle animazioni all'interno dell'insieme Children . Esistono vantaggi e svantaggi per impostare le proprietà della sequenza temporale sul main Storyboard anziché su ogni animazione. Per altre info, vedi Animazioni con storyboard.

È anche necessario un Storyboard per controllare le animazioni predefinite aggiunte ai controlli o all'interfaccia utente, se si usa una delle animazioni dei temi. Le animazioni tema non hanno un punto di attivazione innato, quindi è necessario contenere animazioni tema in uno Storyboard come Bambini. Se lo storyboard viene usato come valore visualState.Storyboard , l'animazione viene eseguita quando viene caricato lo stato visivo. In alternativa, se si trova in un oggetto VisualTransition.Storyboard, l'animazione viene eseguita quando tale transizione viene rilevata dalla gestione stato visivo. Questi sono il modo più comune per usare un'animazione a tema, ma è anche possibile inserirlo in una risorsa Storyboard libera e avviare in modo esplicito l'animazione chiamando Begin. Per altre informazioni su come usare animazioni tema, vedere Avvio rapido: Animare l'interfaccia utente usando animazioni di libreria o animazioni storyboard per gli stati visivi.

Proprietà associate XAML

Storyboard è la classe di servizio host per diverse proprietà associate XAML. Questi consentono animazioni figlio sotto controllo da storyboard a ogni oggetto di destinazione separati da elementi di destinazione e proprietà di destinazione, mentre seguono ancora la stessa sequenza temporale di controllo e il meccanismo di attivazione dell'elemento padre.

Per supportare l'accesso al processore XAML alle proprietà associate e anche per esporre operazioni di get e set equivalenti al codice, ogni proprietà associata XAML ha una coppia di metodi di accesso Get e Set. Un altro modo per ottenere o impostare il valore nel codice consiste nell'usare il sistema delle proprietà di dipendenza, chiamando GetValue o SetValue e passando il campo identificatore come identificatore della proprietà di dipendenza.

Proprietà associata	Descrizione
Targetname	Ottiene o imposta il nome dell'oggetto a cui aggiungere un'animazione.
TargetProperty	Ottiene o imposta la proprietà a cui aggiungere un'animazione.

Costruttori

Storyboard()

Inizializza una nuova istanza della classe Storyboard .

Proprietà

AutoReverse	Ottiene o imposta un valore che indica se la sequenza temporale viene riprodotta in senso inverso dopo il completamento di un'iterazione in avanti. (Ereditato da Timeline)
BeginTime	Ottiene o imposta l'ora in cui deve iniziare questa sequenza temporale . (Ereditato da Timeline)
Children	Ottiene l'insieme di oggetti Sequenza temporale figlio.
Dispatcher	Ottiene CoreDispatcher associato a questo oggetto. CoreDispatcher rappresenta una struttura che può accedere a DependencyObject nel thread dell'interfaccia utente anche se il codice viene avviato da un thread non interfaccia utente. (Ereditato da DependencyObject)
Duration	Ottiene o imposta la durata di riproduzione di questa sequenza temporale, senza contare le ripetizioni. (Ereditato da Timeline)
FillBehavior	Ottiene o imposta un valore che specifica il comportamento dell'animazione dopo che raggiunge la fine del periodo attivo. (Ereditato da Timeline)
RepeatBehavior	Ottiene o imposta il comportamento di ripetizione della sequenza temporale. (Ereditato da Timeline)
SpeedRatio	Ottiene o imposta la frequenza, rispetto al relativo elemento padre, in cui viene eseguito lo stato di avanzamento per questa sequenza temporale. (Ereditato da Timeline)
TargetNameProperty	Identifica la proprietà associata Storyboard.TargetName XAML.
TargetPropertyProperty	Identifica la proprietà associata Storyboard.TargetProperty XAML.

Proprietà associate

TargetName	Ottiene o imposta il nome dell'oggetto a cui aggiungere un'animazione.
TargetProperty	Ottiene o imposta la proprietà a cui aggiungere un'animazione.

Metodi

Begin()	Avvia il set di animazioni associate allo storyboard.
ClearValue(DependencyProperty)	Cancella il valore locale di una proprietà di dipendenza. (Ereditato da DependencyObject)
GetAnimationBaseValue(DependencyProperty)	Restituisce qualsiasi valore di base stabilito per una proprietà di dipendenza, che si applica nei casi in cui un'animazione non è attiva. (Ereditato da DependencyObject)
GetCurrentState()	Ottiene lo stato dell'orologio dello Storyboard.
GetCurrentTime()	Ottiene l'ora dell'orologio dell'animazione corrente dello Storyboard.
GetTargetName(Timeline)	Ottiene il valore della proprietà associata Storyboard.TargetName XAML da un elemento di destinazione.
GetTargetProperty(Timeline)	Ottiene il valore della proprietà associata Storyboard.TargetProperty XAML da un elemento di destinazione.
GetValue(DependencyProperty)	Restituisce il valore effettivo corrente di una proprietà di dipendenza da un oggetto DependencyObject. (Ereditato da DependencyObject)
Pause()	Sospende l'orologio di animazione associato allo storyboard.
ReadLocalValue(DependencyProperty)	Restituisce il valore locale di una proprietà di dipendenza, se viene impostato un valore locale. (Ereditato da DependencyObject)
RegisterPropertyChangedCallback(DependencyProperty, DependencyPropertyChangedCallback)	Registra una funzione di notifica per l'ascolto delle modifiche a un'istanza di DependencyObject specifica. (Ereditato da DependencyObject)
Resume()	Riprende l'orologio dell'animazione o lo stato di esecuzione, associato allo storyboard.
Seek(TimeSpan)	Sposta lo storyboard nella posizione di animazione specificata. Il storyboard esegue la ricerca richiesta quando si verifica il segno di spunta dell'orologio successivo.
SeekAlignedToLastTick(TimeSpan)	Sposta immediatamente il storyboard nella posizione di animazione specificata (in modo sincrono).
SetTarget(Timeline, DependencyObject)	Determina che la sequenza temporale specificata sia destinazione dell'oggetto specificato.
SetTargetName(Timeline, String)	Imposta il valore della proprietà associata Storyboard.TargetName XAML per un elemento di destinazione.
SetTargetProperty(Timeline, String)	Imposta il valore della proprietà associata Storyboard.TargetProperty XAML per un elemento di destinazione.
SetValue(DependencyProperty, Object)	Imposta il valore locale di una proprietà di dipendenza in un oggetto DependencyObject. (Ereditato da DependencyObject)
SkipToFill()	Avanza l'ora corrente dell'orologio dello storyboard alla fine del periodo attivo.
Stop()	Arresta lo storyboard.
UnregisterPropertyChangedCallback(DependencyProperty, Int64)	Annulla una notifica di modifica registrata in precedenza chiamando RegisterPropertyChangedCallback. (Ereditato da DependencyObject)

Eventi

Completed

Si verifica al termine della riproduzione dell'oggetto Storyboard . (Ereditato da Timeline)

Vedi anche

• Timeline
• TimelineCollection
• Storyboard
• Storyboard
• Animazioni con storyboard
• Animazioni con storyboard per stati di visualizzazione
• Animazioni con fotogrammi chiave e con funzioni di interpolazione
• Guida introduttiva: Animazione dell'interfaccia utente con le animazioni della libreria
• Sintassi proprietà-percorso
• Panoramica delle proprietà associate