Storyboard Classe

  • Riferimento

Definizione

Spazio dei nomi:
Microsoft.UI.Xaml.Media.Animation
Modifica

Controlla le animazioni con una sequenza temporale e fornisce informazioni sulla destinazione di oggetti e proprietà per le animazioni figlio.

public ref class Storyboard sealed : Timeline
/// [Microsoft.UI.Xaml.Markup.ContentProperty(Name="Children")]
/// [Windows.Foundation.Metadata.Activatable(65536, "Microsoft.UI.Xaml.WinUIContract")]
/// [Windows.Foundation.Metadata.ContractVersion(Microsoft.UI.Xaml.WinUIContract, 65536)]
/// [Windows.Foundation.Metadata.MarshalingBehavior(Windows.Foundation.Metadata.MarshalingType.Agile)]
/// [Windows.Foundation.Metadata.Threading(Windows.Foundation.Metadata.ThreadingModel.Both)]
class Storyboard final : Timeline
[Microsoft.UI.Xaml.Markup.ContentProperty(Name="Children")]
[Windows.Foundation.Metadata.Activatable(65536, "Microsoft.UI.Xaml.WinUIContract")]
[Windows.Foundation.Metadata.ContractVersion(typeof(Microsoft.UI.Xaml.WinUIContract), 65536)]
[Windows.Foundation.Metadata.MarshalingBehavior(Windows.Foundation.Metadata.MarshalingType.Agile)]
[Windows.Foundation.Metadata.Threading(Windows.Foundation.Metadata.ThreadingModel.Both)]
public sealed class Storyboard : Timeline
Public NotInheritable Class Storyboard
Inherits Timeline
<Storyboard ...>
  oneOrMoreChildTimelines
</Storyboard>
Ereditarietà
Object Platform::Object IInspectable DependencyObject Timeline Storyboard
Attributi
ContentPropertyAttribute ActivatableAttribute ContractVersionAttribute MarshalingBehaviorAttribute ThreadingAttribute

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

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

Commenti

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

Storyboard viene usato per queste proprietà:

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.

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. Storyboard.TargetName viene usato per fare riferimento a un altro elemento in base al nome. L'elemento a cui viene fatto riferimento è l'elemento/oggetto in cui deve essere applicata l'animazione. Questo meccanismo fa parte della progettazione di base del sistema di animazione: consente di dichiarare le risorse di animazione separatamente dalle risorse di dichiarazione dell'interfaccia utente e consente di applicare una definizione di animazione a diversi comportamenti delle proprietà. Per il valore di Storyboard.TargetName in una determinata animazione, specificare il valore dell'attributo Name o x: Name dell'elemento di destinazione, ovvero una stringa. L'elemento denominato deve già esistere in un'altra area del markup XAML.
Il significato delle stringhedell'attributo Name x:Name/ è controllato da un concetto di nomescope XAML. Per la maggior parte degli scenari di destinazione dell'animazione, non è necessario preoccuparsi dell'influenza dei nomi XAML, ma è possibile che si verifichino problemi di risoluzione dei nomi XAML se si tenta di creare parti modello o oggetti creati usando XamlReader.Load e successivamente aggiunti all'albero degli oggetti. Per altre info, vedi Ambiti dei nomi XAML.
TargetProperty Ottiene o imposta la proprietà a cui aggiungere un'animazione.Storyboard.TargetProperty è destinata a una determinata proprietà dell'elemento specificato da Storyboard.TargetName. Il valore specificato per Storyboard.TargetProperty implica un concetto noto come percorso di proprietà. Per altre informazioni su come specificare un percorso di proprietà per un'animazione, vedere Osservazioni in SetTargetProperty o Storyboard.TargetProperty o l'argomento sintassi Property-path .

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

Restituisce null sempre in un'app SDK per app di Windows. Usare invece DispatcherQueue .

(Ereditato da DependencyObject)
DispatcherQueue

Ottiene l'oggetto DispatcherQueue associato. Rappresenta DispatcherQueue una struttura che può accedere al thread dell'interfaccia utente anche se il codice viene avviato da un thread non dell'interfaccia DependencyObject 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)

Si applica a

Vedi anche