VisualState Class


Represents the visual appearance of a UI element when it is in a specific state. Visual states use Setters or a Storyboard to set UI properties within pages or control templates where the VisualState is defined.

public ref class VisualState sealed : DependencyObject
/// [Microsoft.UI.Xaml.Markup.ContentProperty(Name="Storyboard")]
/// [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)]
/// [Windows.Foundation.Metadata.WebHostHidden]
class VisualState final : DependencyObject
[Windows.Foundation.Metadata.Activatable(65536, "Microsoft.UI.Xaml.WinUIContract")]
[Windows.Foundation.Metadata.ContractVersion(typeof(Microsoft.UI.Xaml.WinUIContract), 65536)]
public sealed class VisualState : DependencyObject
Public NotInheritable Class VisualState
Inherits DependencyObject
<VisualState x:Name="stateName" />
<VisualState x:Name="stateName">
<VisualState x:Name="stateName">
<VisualState x:Name="stateName">
ContentPropertyAttribute Windows.Foundation.Metadata.ActivatableAttribute Windows.Foundation.Metadata.ContractVersionAttribute Windows.Foundation.Metadata.MarshalingBehaviorAttribute Windows.Foundation.Metadata.ThreadingAttribute Windows.Foundation.Metadata.WebHostHiddenAttribute


This example creates a VisualStateGroup in the ControlTemplate of a Button called "CommonStates" and adds VisualState objects for the states, "Normal", "Pressed", and "PointerOver". The Button also defines a state called "Disabled" that is in the "CommonStates" named VisualStateGroup, but the example omits it for brevity.

<ControlTemplate TargetType="Button">
  <Border x:Name="RootElement">


      <!--Define the states for the common states.
          The states in the VisualStateGroup are mutually exclusive to
          each other.-->
      <VisualStateGroup x:Name="CommonStates">

        <!--The Normal state is the state the button is in
            when it is not in another state from this VisualStateGroup.-->
        <VisualState x:Name="Normal" />

        <!--Change the SolidColorBrush, BorderBrush, to red when the
            Pointer is over the button.-->
        <VisualState x:Name="PointerOver">
            <ColorAnimation Storyboard.TargetName="BorderBrush" 
                              Storyboard.TargetProperty="Color" To="Red" />



        <!--Change the SolidColorBrush, BorderBrush, to Transparent when the
            button is pressed.-->
        <VisualState x:Name="Pressed">
          <Storyboard >
            <ColorAnimation Storyboard.TargetName="BorderBrush" 
                              Storyboard.TargetProperty="Color" To="Transparent"/>
          <!--The Disabled state is omitted for brevity.-->

      <SolidColorBrush x:Name="BorderBrush" Color="Black"/>

    <Grid Background="{TemplateBinding Background}" Margin="4">
        HorizontalAlignment="{TemplateBinding HorizontalContentAlignment}"
        VerticalAlignment="{TemplateBinding VerticalContentAlignment}"
        Margin="4,5,4,4" />


    <Grid Background="{ThemeResource ApplicationPageBackgroundThemeBrush}">
                        <!-- VisualState to be triggered when window width is >=720 effective pixels -->
                        <AdaptiveTrigger MinWindowWidth="720"/>
                        <Setter Target="myPanel.Orientation" Value="Horizontal"/>
        <StackPanel x:Name="myPanel" Orientation="Vertical">
            <TextBlock x:Name="myTextBlock" MaxLines="5" Style="{ThemeResource BodyTextBlockStyle}"/>


A VisualState element must always be contained within a VisualStateGroup parent in the XAML markup. The VisualStateGroup has an implicit collection property States, so you can put each VisualState as an immediate child element of the VisualStateGroup parent. For example:

<VisualStateGroup x:Name="CommonStates">
   <VisualState x:Name="Normal"/>
   <VisualState x:Name="PointerOver">...</VisualState>
<!-- do not need explicit VisualStateGroups.States property element, States is the XAML content property-->

When you use StateTriggers, ensure that the VisualStateGroup is declared under the first child of the root in order for the triggers to take effect automatically.

Default state

It's legal and common to define a VisualState that has an x:Name attribute but doesn't specify anything in the Storyboard. This is useful because such a VisualState will use whatever values are present in the default template. You can then specifically request the empty state from a GoToState call. When an empty state becomes the current state, that cancels all modifications to template properties made by a previous visual state from the same VisualStateGroup. For more info on how to use groups for visual states, see Storyboarded animations for visual states.

When you use StateTriggers, you are no longer required to create an empty VisualState to call GoToState on. When the conditions for a StateTrigger are no longer met, all the modifications to the properties made by the corresponding VisualState are automatically removed and the values provided in the default markup take effect.

VisualState and x:Name

The GoToState method (which is typically called from control code) requires a stateName parameter to inform the VisualStateManager which state should be used as a current state. Specify an x:Name attribute for each VisualState that will need to be manually applied using a GoToState call from code. If you are using StateTriggers to automatically trigger a VisualState from markup, you don’t need to specify an x:Name attribute on that VisualState.

If you use visual transitions, the x:Name attribute value of a VisualState is also referenced by the From or To values of a VisualTransition. In this case the name identifies the state or states that the VisualTransition provides the intermediate values between.

The x:Name attribute value that you specify for a VisualState must be unique within the control template XAML where the VisualState exists. Scope for state names isn't just scoped for each VisualStateGroup, it's scoped to all visual states in the template. For example, you can't define two different states named "Focused" in the same template XAML, even if they are in different groups.

You must use the x:Name attribute to name a visual state or visuals state group; the unprefixed attribute "Name" won't work. VisualState and VisualStateGroup each have a Name property but these are read-only. That Name property exists for advanced scenarios that use code to examine a control template's content at run-time, not for setting from XAML.

Replacing an existing control's control template

If you are an app developer using a control in your app UI, you can replace the control template by setting the Control.Template property to a different value. Or you can replace the template by declaring a new style that uses the implicit style key for that control. For more info on these concepts, see Quickstart: Control templates.

When you replace a control template, it's important that you reproduce all the existing named VisualState elements from the original control template's VisualStateManager.VisualStateGroups content in XAML. The control code (which you aren't modifying) is calling GoToState. States with those names must exist in the control template. A request for a missing VisualState won't throw exceptions, but it often will leave the control in a visual state that will be confusing to the user. For example, if you don't supply a VisualState named "Checked" for a CheckBox control, no visual feedback appears when the user selects the control. The user will expect that there's something visually different to distinguish a checked CheckBox from an unchecked CheckBox. So a failure to reproduce the visual states on the app developer's part will make the control seem broken to the user.

When you use an IDE such as Microsoft Visual Studio, the actions that you use to replace a control template provide the option to start with a copy of the original template XAML, so you can see all the original named VisualState elements and other control composition you are replacing. It's best to start with template copies, then modify them, so that you don't accidentally omit an expected visual state from your new template.

Attributing a custom control's named visual states

If you are defining a custom control that has visual states in its control template XAML, it's a best practice to attribute the control class to indicate to control consumers which visual states are available. To do this, apply one or more TemplateVisualState attributes at the class level of your control definition code. Each attribute should specify the state's x:Name attribute, which is the stateName value a control consumer would pass in a GoToState call to use that visual state. If the VisualState is part of a VisualStateGroup, that should also be indicated in your attribute values.



Initializes a new instance of the VisualState class.



Gets the CoreDispatcher that this object is associated with. The CoreDispatcher represents a facility that can access the DependencyObject on the UI thread even if the code is initiated by a non-UI thread.

(Inherited from DependencyObject)

Gets the DispatcherQueue that this object is associated with. The DispatcherQueue represents a facility that can access the DependencyObject on the UI thread even if the code is initiated by a non-UI thread.

(Inherited from DependencyObject)

Gets the name of the VisualState.


Gets a collection of Setter objects that define discrete property values that control the appearance of UIElement s when this VisualState is applied.


Gets a collection of StateTriggerBase objects that indicate when this VisualState should be applied. If any (not all) of the triggers are active, the VisualState will be applied.


Gets or sets a Storyboard that defines state-specific property values and appearance of the control when it is using this visual state.



Clears the local value of a dependency property.

(Inherited from DependencyObject)

Returns any base value established for a dependency property, which would apply in cases where an animation is not active.

(Inherited from DependencyObject)

Returns the current effective value of a dependency property from a DependencyObject.

(Inherited from DependencyObject)

Returns the local value of a dependency property, if a local value is set.

(Inherited from DependencyObject)
RegisterPropertyChangedCallback(DependencyProperty, DependencyPropertyChangedCallback)

Registers a notification function for listening to changes to a specific DependencyProperty on this DependencyObject instance.

(Inherited from DependencyObject)
SetValue(DependencyProperty, Object)

Sets the local value of a dependency property on a DependencyObject.

(Inherited from DependencyObject)
UnregisterPropertyChangedCallback(DependencyProperty, Int64)

Cancels a change notification that was previously registered by calling RegisterPropertyChangedCallback.

(Inherited from DependencyObject)

Applies to

See also