VisualStateManager.GoToState(Control, String, Boolean) Metodo

public:
 static bool GoToState(Control ^ control, Platform::String ^ stateName, bool useTransitions);

 static bool GoToState(Control const& control, winrt::hstring const& stateName, bool const& useTransitions);

public static bool GoToState(Control control, string stateName, bool useTransitions);

function goToState(control, stateName, useTransitions)

Public Shared Function GoToState (control As Control, stateName As String, useTransitions As Boolean) As Boolean

Parametri

Valori restituiti

true se il controllo passa correttamente al nuovo stato o usa già tale stato; in caso contrario, false.

Esempio

In questo esempio viene illustrata la logica di controllo che usa il metodo GoToState per eseguire la transizione tra stati.

private void UpdateStates(bool useTransitions)
{
    if (Value >= 0)
    {
        VisualStateManager.GoToState(this, "Positive", useTransitions);
    }
    else
    {
        VisualStateManager.GoToState(this, "Negative", useTransitions);
    }

    if (isFocused)
    {
        VisualStateManager.GoToState(this, "Focused", useTransitions);
    }
    else
    {
        VisualStateManager.GoToState(this, "Unfocused", useTransitions);
    }

}

<ResourceDictionary 
    xmlns="http://schemas.microsoft.com/winfx/2006/xaml/presentation" 
    xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml" 
    xmlns:local="using:NumericUpDownCustomControl"
    >
    <Style TargetType="local:NumericUpDown">
        <Setter Property="Template">
            <Setter.Value>
                <ControlTemplate TargetType="local:NumericUpDown">
                    <Grid  Margin="3" 
                Background="{TemplateBinding Background}">
                        <VisualStateManager.VisualStateGroups>
                            <VisualStateGroup x:Name="ValueStates">
                                
                                <!--Make the Value property red when it is negative.-->
                                <VisualState x:Name="Negative">
                                    <Storyboard>
                                        <ColorAnimation To="Red"
                                    Storyboard.TargetName="TextBlock" 
                                    Storyboard.TargetProperty="(Foreground).(SolidColorBrush.Color)"/>
                                    </Storyboard>
                                </VisualState>
                                <!--Return the control to its initial state by
                    return the TextBlock Foreground to its 
                    original color.-->
                                <VisualState x:Name="Positive" />
                            </VisualStateGroup>

                            <VisualStateGroup x:Name="FocusStates">
                                <!--Add a focus rectangle to highlight the entire control
                    when it has focus.-->
                                <VisualState x:Name="Focused">
                                    <Storyboard>
                                        <ObjectAnimationUsingKeyFrames Storyboard.TargetName="FocusVisual" 
                                                   Storyboard.TargetProperty="Visibility" Duration="0">
                                            <DiscreteObjectKeyFrame KeyTime="0">
                                                <DiscreteObjectKeyFrame.Value>
                                                    <Visibility>Visible</Visibility>
                                                </DiscreteObjectKeyFrame.Value>
                                            </DiscreteObjectKeyFrame>
                                        </ObjectAnimationUsingKeyFrames>
                                    </Storyboard>
                                </VisualState>
                                <!--Return the control to its initial state by
                    hiding the focus rectangle.-->
                                <VisualState x:Name="Unfocused"/>
                            </VisualStateGroup>
                        </VisualStateManager.VisualStateGroups>

                        <Grid>
                            <Grid.RowDefinitions>
                                <RowDefinition/>
                                <RowDefinition/>
                            </Grid.RowDefinitions>
                            <Grid.ColumnDefinitions>
                                <ColumnDefinition/>
                                <ColumnDefinition/>
                            </Grid.ColumnDefinitions>

                            <Border BorderThickness="1" BorderBrush="Gray" 
                    Margin="7,2,2,2" Grid.RowSpan="2" 
                    Background="#E0FFFFFF"
                    VerticalAlignment="Center" 
                    HorizontalAlignment="Stretch">
                                <TextBlock x:Name="TextBlock" TextAlignment="Center" Padding="5"
                           Foreground="{TemplateBinding Foreground}"/>

                            </Border>

                            <RepeatButton Content="Up" Margin="2,5,5,0" 
                          x:Name="UpButton"
                          Grid.Column="1" Grid.Row="0"
                          Foreground="Green"/>
                            <RepeatButton Content="Down" Margin="2,0,5,5" 
                          x:Name="DownButton"
                          Grid.Column="1" Grid.Row="1" 
                          Foreground="Green"/>

                            <Rectangle Name="FocusVisual" Grid.ColumnSpan="2" Grid.RowSpan="2" 
                       Stroke="Red" StrokeThickness="1"  
                       Visibility="Collapsed"/>
                        </Grid>

                    </Grid>
                </ControlTemplate>
            </Setter.Value>
        </Setter>
    </Style>
    
</ResourceDictionary>

Commenti

Questo metodo viene usato dalla logica di controllo. In genere è necessario solo se si scrive un controllo personalizzato o se si usa la logica a livello di app per gli stati di visualizzazione, ad esempio l'aggiornamento del contenuto dell'app per le modifiche apportate alle dimensioni o all'orientamento della finestra dell'app.

Quando chiami questo metodo, dovrebbe essere presente un oggetto VisualState con un x:Name valore corrispondente stateName al valore, in un punto qualsiasi del modello di controllo per il controllo identificato da controlo come risorsa per l'app. In caso contrario, non si ottengono eccezioni, ma il valore restituito sarà false. Lo stato denominato da stateName può trovarsi in uno degli elementi VisualStateGroup nel modello per il controllo specificato. È necessario tenere traccia degli stati in cui VisualStateGroup e sapere quale stato viene scaricato quando si specifica un nuovo stato da tale gruppo.

In genere , ControlTemplate che contiene gli stati di visualizzazione a cui si fa riferimento per nome quando si usa GoToState non è definito specificamente per l'istanza del controllo. Gli stati di visualizzazione provengono invece dallo stile di controllo predefinito caricato come stile implicito per tutte le istanze di tale controllo. Per altre info sul concetto di stile implicito, vedi Modelli di controllo XAML.

VisualStateManager supporta due funzionalità importanti per gli autori di controlli e per gli sviluppatori di app che applicano un modello personalizzato a un controllo:

• Gli autori di controlli o gli sviluppatori di app aggiungono elementi oggetto VisualStateGroup all'elemento radice di una definizione di modello di controllo in XAML, usando la VisualStateManager.VisualStateGroups proprietà associata. All'interno di un VisualStateGroup elemento, ogni Oggetto VisualState rappresenta uno stato di visualizzazione discreto di un controllo. Ogni VisualState oggetto ha un nome rappresentativo di uno stato dell'interfaccia utente che può essere modificato dall'utente o modificato dalla logica di controllo. Un VisualState oggetto è costituito principalmente da uno Storyboard. Questa Storyboard proprietà è destinata ai singoli valori delle proprietà di dipendenza che devono essere applicati ogni volta che il controllo si trova in tale stato di visualizzazione.
• Gli autori di controlli o gli sviluppatori di app passano tra questi stati chiamando il metodo Statico GoToState di VisualStateManager. Gli autori di controlli eseguono questa operazione ogni volta che la logica di controllo gestisce gli eventi che indicano una modifica dello stato o la logica di controllo avvia una modifica dello stato da sola. È più comune che il codice di definizione del controllo e non il codice dell'app, in modo che tutti gli stati visivi possibili e le relative transizioni e condizioni di trigger siano presenti per impostazione predefinita per il codice dell'app. In alternativa, è il codice dell'app che modifica gli stati di visualizzazione per gestire gli stati di visualizzazione a livello di app in risposta alle modifiche guidate dall'utente alle dimensioni o all'orientamento della finestra principale dell'app.

Quando si chiama GoToState per modificare lo stato di visualizzazione di un controllo, VisualStateManager esegue queste azioni:

• Prima di tutto viene determinato se esiste uno stato corrispondente stateName . In caso contrario, non accade nulla e il metodo restituisce false.
• Se VisualState come denominato da stateName esiste e ha uno Storyboard, inizia lo storyboard.
• Se l'oggetto VisualState utilizzato dal controllo dallo stesso Oggetto VisualStateGroup prima dello stato appena richiesto ha uno Storyboard, tale storyboard si arresta. Oltre alle proprietà specifiche a cui il nuovo VisualState applica un'animazione, il controllo viene ripristinato agli stati inizialmente caricati dal modello di controllo e dalla relativa composizione.

Se il controllo è già presente in VisualState richiesto come stateName, GoToState restituisce true, ma non è presente alcuna azione (lo storyboard non verrà riavviato).

Un modello di implementazione comune del controllo consiste nel definire un singolo metodo privato della classe di controllo che si occupa di tutte le possibili modifiche di VisualState per il controllo. Lo stato di visualizzazione da usare è determinato controllando le proprietà del controllo. Queste proprietà potrebbero essere pubbliche o private. I valori delle proprietà vengono regolati dai gestori nella logica di controllo per eventi come OnGotFocus e vengono controllati immediatamente prima di impostare lo stato di visualizzazione. L'esempio di codice in questo argomento usa questo modello di implementazione. In alternativa, è possibile chiamare GoToState per singoli stati dai gestori eventi, dagli override del gestore eventi di controllo (i metodi OnEvent ) o dai metodi helper chiamati da tutti i possibili impulsi per modificare gli stati (eventi guidati dall'utente, eventi di automazione, logica di inizializzazione).

È anche possibile chiamare GoToState dall'implementazione di PropertyChangedCallback per una proprietà di dipendenza personalizzata.

Stati di visualizzazione e transizioni

Oltre agli stati di visualizzazione, il modello di stato di visualizzazione include anche transizioni. Le transizioni sono azioni di animazione controllate da uno Storyboard che si verificano tra ogni stato di visualizzazione quando lo stato viene modificato. La transizione può essere definita in modo diverso per ogni combinazione di stato iniziale e di stato finale, come definito dal set di stati di visualizzazione del controllo. Le transizioni sono definite dalla proprietà Transitions di VisualStateGroup e sono in genere definite in XAML. La maggior parte dei modelli di controllo predefiniti non definisce le transizioni e in questo caso le transizioni tra gli stati vengono eseguite istantaneamente. Per altre info, vedi VisualTransition.

È anche possibile definire un oggetto VisualTransition in modo da produrre una transizione implicita. Qualsiasi proprietà di dipendenza specificamente destinata all'animazione negli stati di visualizzazione From oTo di un VisualTransition oggetto e ha valori diversi nella modifica dello stato può essere animata con un'animazione di transizione implicita. Questa animazione generata passa tra il valore From state e il valore To state di tale proprietà usando l'interpolazione. L'animazione di transizione implicita dura per l'ora indicata dal valore GeneratedDuration di un oggetto VisualTransition. Le transizioni implicite si applicano solo alle proprietà che sono un valore Double, Color o Point . In altre parole, la proprietà deve essere possibile animare in modo implicito usando doubleAnimation, PointAnimation o ColorAnimation. Per altre info, vedi GeneratedDuration.

Eventi per le modifiche dello stato di visualizzazione

CurrentStateChanging viene attivato quando il controllo inizia a eseguire la transizione degli stati come richiesto dalla GoToState chiamata. Se un oggetto VisualTransition viene applicato alla modifica dello stato, questo evento si verifica all'inizio della transizione.

CurrentStateChanged viene attivato dopo che il controllo è nello stato richiesto dalla GoToState chiamata, proprio come inizia il nuovo storyboard . Nessun evento viene generato al completamento del nuovo storyboard.

Se un oggetto VisualTransition non viene applicato, CurrentStateChanging e CurrentStateChanged vengono attivati in rapida successione, ma sono garantiti in tale ordine se entrambi si verificano.

Tuttavia, se una transizione di modifica dello stato viene interrotta da una nuova GoToState chiamata, l'evento CurrentStateChanged non viene mai generato per la transizione del primo stato. Viene generata una nuova serie di eventi per la successiva modifica dello stato richiesta.

OnApplyTemplate non viene richiamato per le modifiche dello stato di visualizzazione. OnApplyTemplate viene richiamato solo per il caricamento iniziale di un controllo in un'interfaccia utente XAML.

Attributi degli stati di visualizzazione denominati di un controllo personalizzato

Se si definisce un controllo personalizzato con stati di visualizzazione nel codice XAML del modello di controllo, è consigliabile attribuire la classe di controllo per indicare ai consumer quali stati di visualizzazione sono disponibili. A tale scopo, applicare uno o più attributi TemplateVisualState a livello di classe del codice di definizione del controllo. Ogni attributo deve specificare l'attributo x:Name dello stato, ovvero il valore stateName che un consumer di controllo passerebbe in una GoToState chiamata per usare tale stato di visualizzazione. Se VisualState fa parte di un oggetto VisualStateGroup, deve essere indicato anche nella definizione dell'attributo.

Un concetto correlato è che gli autori di controlli devono attribuire i nomi delle parti di controllo chiave usando TemplatePartAttribute. Ciò è molto utile se i consumer di controllo vogliono accedere a parti denominate dall'ambito del modello dopo l'applicazione del modello. TemplateVisualStateAttribute e TemplatePartAttribute consentono di definire il contratto di controllo per un controllo.

VisualStateManager personalizzato

Come scenario avanzato, è possibile derivare da VisualStateManager e modificare il comportamento predefinito GoToState . La classe derivata deve eseguire l'override del metodo GoToStateCore protetto. Qualsiasi istanza di VisualStateManager personalizzata usa questa logica Core quando viene chiamato il relativo GoToState metodo.

Stati di visualizzazione per gli stati di visualizzazione dell'app

Gli stati di visualizzazione non sono necessariamente per i controlli personalizzati. È possibile usare gli stati di visualizzazione dei nuovi modelli di controllo applicati a qualsiasi istanza di Control in cui si sostituisce il modello predefinito impostando la proprietà Template . Per configurare questa operazione, è necessario definire il modello di controllo e gli stati di visualizzazione che si prevede di usare come risorsa style che si trova in Page.Resources o Application.Resources. È sempre consigliabile iniziare con una copia del modello predefinito e modificare solo alcuni aspetti del modello o anche solo modificare alcuni stati di visualizzazione e lasciare la composizione di base da sola. Per altre info, vedi Modelli di controllo XAML.

Gli stati di visualizzazione possono essere usati per modificare le proprietà di una pagina o dei controlli all'interno della pagina per tenere conto dell'orientamento della finestra dell'app. I valori delle proprietà relative al layout del controllo o alla composizione potrebbero cambiare a seconda che l'orientamento complessivo sia verticale o orizzontale. Per altre info su questo scenario per GoToState, vedi Layout reattivi con XAML.

Stati di visualizzazione per gli elementi che non sono controlli

Gli stati di visualizzazione sono talvolta utili per gli scenari in cui si vuole modificare lo stato di un'area dell'interfaccia utente che non è immediatamente una sottoclasse Control . Non è possibile eseguire questa operazione direttamente perché il parametro di controllo del GoToState metodo richiede una Control sottoclasse, che fa riferimento all'oggetto su cui agisce VisualStateManager . Page è una Control sottoclasse ed è piuttosto raro che si mostri l'interfaccia utente in un contesto in cui non si dispone di un Pageoggetto o la radice Window.Content non è una Control sottoclasse. È consigliabile definire un oggetto UserControl personalizzato come radice o essere Window.Content un contenitore per altri contenuti a cui si desidera applicare gli stati, ad esempio un pannello. È quindi possibile chiamare GoToState gli UserControl stati e applicare indipendentemente dal fatto che il resto del contenuto sia un oggetto Control. Ad esempio, è possibile applicare gli stati di visualizzazione all'interfaccia utente che in caso contrario sono costituiti da un oggetto SwapChainPanel , purché sia stato inserito all'interno UserControl degli stati denominati e dichiarati che si applicano alle proprietà dell'elemento padre UserControl o della parte denominata SwapChainPanel del modello.

Vedi anche

• GoToStateCore(Control, FrameworkElement, String, VisualStateGroup, VisualState, Boolean)
• TemplateVisualStateAttribute
• VisualStateGroup
• VisualState
• Modelli di controllo XAML
• Attributo x:Name