VisualStateManager.GoToState(Control, String, Boolean) Méthode

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

Paramètres

Retours

true si le contrôle passe correctement à l’état nouveau ou utilise déjà cet état ; sinon, false.

Exemples

Cet exemple illustre la logique de contrôle qui utilise la méthode GoToState pour passer d’un état à l’autre.

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>

Remarques

Cette méthode est utilisée par la logique de contrôle. En règle générale, vous n’en avez besoin que si vous écrivez un contrôle personnalisé ou si vous utilisez une logique au niveau de l’application pour les états d’affichage (par exemple, l’actualisation du contenu de votre application pour les modifications apportées à la taille ou à l’orientation de la fenêtre d’application).

Lorsque vous appelez cette méthode, il est prévu qu’il s’agit d’un VisualState avec une x:Name valeur qui correspond à votre stateName valeur, quelque part dans le modèle de contrôle du contrôle identifié par control, ou en tant que ressource pour votre application. Si ce n’est pas le cas, vous n’obtenez pas d’exceptions, mais la valeur de retour sera false. L’état nommé par stateName peut se trouver dans l’un des éléments VisualStateGroup du modèle pour le contrôle spécifié. Il vous appartient de suivre les états dans lesquels VisualStateGroup et de savoir quel état est déchargé lorsque vous spécifiez un nouvel état à partir de ce groupe.

En règle générale, le ControlTemplate qui contient les états visuels comme référencés par son nom lors de l’utilisation GoToState n’est pas spécifiquement défini pour cette instance de contrôle. Au lieu de cela, les états visuels proviennent du style de contrôle par défaut chargé comme style implicite pour toutes les instances de ce contrôle. Pour plus d’informations sur le concept de style implicite, consultez les modèles de contrôle XAML.

VisualStateManager prend en charge deux fonctionnalités importantes pour les auteurs de contrôles et pour les développeurs d’applications qui appliquent un modèle personnalisé à un contrôle :

• Les auteurs de contrôles ou les développeurs d’applications ajoutent des éléments d’objet VisualStateGroup à l’élément racine d’une définition de modèle de contrôle en XAML, à l’aide de la VisualStateManager.VisualStateGroups propriété jointe. Dans un VisualStateGroup élément, chaque VisualState représente un état visuel discret d’un contrôle. Chacun VisualState a un nom représentatif d’un état d’interface utilisateur qui peut être modifié par l’utilisateur ou modifié par la logique de contrôle. A VisualState se compose principalement d’un Storyboard. Cela Storyboard cible les valeurs de propriété de dépendance individuelles qui doivent être appliquées chaque fois que le contrôle est dans cet état visuel.
• Les auteurs de contrôle ou les développeurs d’applications passent entre ces états en appelant la méthode Statique GoToState de VisualStateManager. Les auteurs de contrôles effectuent cette opération chaque fois que la logique de contrôle gère les événements qui indiquent un changement d’état, ou que la logique de contrôle initie une modification d’état elle-même. Il est plus courant que le code de définition de contrôle effectue cette opération plutôt que le code d’application, afin que tous les états visuels possibles et leurs transitions et conditions de déclencheur soient là par défaut pour le code d’application. Ou bien, il s’agit du code d’application qui change d’états visuels, pour gérer les états d’affichage au niveau de l’application en réponse aux modifications pilotées par l’utilisateur à la taille ou à l’orientation de la fenêtre principale de l’application.

Lorsque vous appelez GoToState pour modifier l’état visuel d’un contrôle, VisualStateManager effectue ces actions :

• Tout d’abord, il est déterminé si un état qui correspond stateName existe. Si ce n’est pas le cas, rien ne se produit et la méthode retourne false.
• Si visualState tel qu’il stateName existe, et qu’il a un storyboard, le storyboard commence.
• Si visualState utilisé par le contrôle à partir de ce même VisualStateGroup avant que l’état nouvellement demandé ait un storyboard, ce storyboard s’arrête. À part les propriétés spécifiques auxquelles le nouveau VisualState applique une animation, le contrôle revient aux états initialement chargés à partir du modèle de contrôle et de sa composition.

Si le contrôle se trouve déjà dans visualState demandé en tant que stateName, retourne true, GoToState mais il n’existe pas d’action dans le cas contraire (le storyboard ne sera pas redémarré).

Un modèle d’implémentation de contrôle commun consiste à définir une méthode privée unique de la classe de contrôle qui s’occupe de toutes les modifications Possibles de VisualState pour le contrôle. L’état visuel à utiliser est déterminé en vérifiant les propriétés du contrôle. Ces propriétés peuvent être publiques ou privées. Les valeurs des propriétés sont ajustées par les gestionnaires dans la logique de contrôle pour les événements tels que OnGotFocus et sont vérifiées juste-à-temps juste-à-temps avant de définir l’état visuel. L’exemple de code de cette rubrique utilise ce modèle d’implémentation. Vous pouvez également appeler GoToState pour des états individuels à partir de gestionnaires d’événements, des remplacements de gestionnaires d’événements de contrôle (méthodes OnEvent ) ou des méthodes d’assistance appelées par tous les impulsions possibles pour changer d’état (événements pilotés par l’utilisateur, événements d’automatisation, logique d’initialisation).

Vous pouvez également appeler GoToState à partir de l’implémentation PropertyChangedCallback pour une propriété de dépendance personnalisée.

États visuels et transitions

Outre les états visuels, le modèle d’état visuel inclut également des transitions. Les transitions sont des actions d’animation contrôlées par un Storyboard qui se produisent entre chaque état visuel lorsque l’état est modifié. La transition peut être définie différemment pour chaque combinaison d’état de départ et d’état de fin tel que défini par l’ensemble d’états visuels de votre contrôle. Les transitions sont définies par la propriété Transitions de VisualStateGroup et sont généralement définies en XAML. La plupart des modèles de contrôle par défaut ne définissent pas de transitions et, dans ce cas, les transitions entre les états se produisent instantanément. Pour plus d’informations, consultez VisualTransition.

VisualTransition peut également être défini de telle sorte qu’il produit une transition implicite. Toute propriété de dépendance spécifiquement ciblée pour l’animation dans les états visuels From ouTo d’un VisualTransition et qui a des valeurs différentes dans le changement d’état peut être animée avec une animation de transition implicite. Cette animation générée passe entre la valeur d’état From et la valeur To state d’une telle propriété à l’aide de l’interpolation. L’animation de transition implicite dure pour l’heure indiquée par la valeur GeneratedDuration d’un VisualTransition. Les transitions implicites s’appliquent uniquement aux propriétés qui sont une valeur double, couleur ou point . En d’autres termes, la propriété doit être possible d’animer implicitement à l’aide d’un objet DoubleAnimation, PointAnimation ou ColorAnimation. Pour plus d’informations, consultez GeneratedDuration.

Événements pour les modifications d’état visuel

CurrentStateChanging se déclenche lorsque le contrôle commence à passer des états comme demandé par l’appel GoToState . Si un VisualTransition est appliqué au changement d’état, cet événement se produit au début de la transition.

CurrentStateChanged se déclenche une fois que le contrôle est dans l’état demandé par l’appel GoToState , tout comme le nouveau Storyboard commence. Aucun événement n’est déclenché sur la fin du nouveau storyboard.

Si un VisualTransition n’est pas appliqué, CurrentStateChanging et CurrentStateChanged se déclenchent en succession rapide, mais sont garantis dans cet ordre si les deux se produisent.

Toutefois, si une transition de modification d’état est interrompue par un nouvel GoToState appel, l’événement CurrentStateChanged n’est jamais déclenché pour la première transition d’état. Une nouvelle série d’événements est déclenchée pour la modification d’état demandée suivante.

OnApplyTemplate n’est pas appelé pour les modifications d’état visuel. OnApplyTemplate est appelé uniquement pour la charge initiale d’un contrôle dans une interface utilisateur XAML.

Attribution d’états visuels nommés d’un contrôle personnalisé

Si vous définissez un contrôle personnalisé qui a des états visuels dans son modèle de contrôle XAML, il est recommandé d’attribuer la classe de contrôle pour indiquer aux consommateurs quels états visuels sont disponibles. Pour ce faire, appliquez un ou plusieurs attributs TemplateVisualState au niveau de la classe de votre code de définition de contrôle. Chaque attribut doit spécifier l’attribut x :Name de l’état, qui est la valeur stateName qu’un consommateur de contrôle passerait un GoToState appel pour utiliser cet état visuel. Si VisualState fait partie d’un VisualStateGroup, il doit également être indiqué dans la définition d’attribut.

Un concept associé est que les auteurs de contrôles doivent attribuer les noms des composants de contrôle clés à l’aide de TemplatePartAttribute. Cela est très utile si les consommateurs contrôlent l’accès aux parties nommées à partir de l’étendue du modèle après l’application du modèle. TemplateVisualStateAttribute et TemplatePartAttribute aident à définir le contrat de contrôle d’un contrôle.

Custom VisualStateManager

En tant que scénario avancé, il est possible de dériver de VisualStateManager et de modifier le comportement par défaut GoToState . La classe dérivée doit remplacer la méthode GoToStateCore protégée. Toute instance de VisualStateManager personnalisée utilise cette logique principale quand sa GoToState méthode est appelée.

États visuels pour les états d’affichage d’application

Les états visuels ne sont pas nécessairement destinés aux contrôles personnalisés. Vous pouvez utiliser des états visuels à partir de nouveaux modèles de contrôle que vous appliquez à n’importe quelle instance de contrôle où vous remplacez le modèle par défaut en définissant la propriété Template . Pour configurer ce paramètre, vous devez définir le modèle de contrôle et les états visuels que vous envisagez d’utiliser en tant que ressource style qui se trouve dans l’une ou l’autre Page.Resources .Application.Resources Il est toujours préférable de commencer par une copie du modèle par défaut et de modifier uniquement certains aspects du modèle ou même simplement de modifier certains états visuels et de laisser la composition de base seule. Pour plus d’informations, consultez les modèles de contrôle XAML.

Les états visuels peuvent être utilisés pour modifier les propriétés d’une page ou des contrôles dans la page pour tenir compte de l’orientation de la fenêtre d’application. Votre composition ou les valeurs de propriété liées à la disposition de votre contrôle peuvent changer selon que l’orientation globale est portrait ou paysage. Pour plus d’informations sur ce scénario GoToState, consultez les dispositions réactives avec XAML.

États visuels des éléments qui ne sont pas des contrôles

Les états visuels sont parfois utiles pour les scénarios où vous souhaitez modifier l’état d’une zone d’interface utilisateur qui n’est pas immédiatement une sous-classe Contrôle . Vous ne pouvez pas le faire directement, car le paramètre de contrôle de la GoToState méthode nécessite une Control sous-classe, qui fait référence à l’objet sur lequel le VisualStateManager agit. La page est une Control sous-classe, et il est assez rare que vous affichiez l’interface utilisateur dans un contexte où vous n’avez pas de Pagesous-classe, ou votre racine Window.Content n’est pas une Control sous-classe. Nous vous recommandons de définir un UserControl personnalisé pour être la Window.Content racine ou être un conteneur pour d’autres contenus auquel vous souhaitez appliquer des états (par exemple, un panneau). Vous pouvez ensuite appeler GoToState vos UserControl états et les appliquer, que le reste du contenu soit un Control. Par exemple, vous pouvez appliquer des états visuels à l’interface utilisateur qui, sinon, se compose simplement d’un SwapChainPanel tant que vous l’avez placé dans vos UserControl états nommés et déclarés qui s’appliquent aux propriétés du parent UserControl ou de la partie nommée SwapChainPanel du modèle.

Voir aussi

• GoToStateCore(Control, FrameworkElement, String, VisualStateGroup, VisualState, Boolean)
• TemplateVisualStateAttribute
• VisualStateGroup
• VisualState
• Modèles de contrôle XAML
• attribut x :Name