Silverlight DataStateBeHavior, valor inicial não usado
-
22-09-2019 - |
Pergunta
Estou tentando usar o DataStateBeHavior do Silverlight, ele funciona bem na maioria dos casos em que clico em um botão que define uma propriedade 'selecionada' no modelo de visualização para False ou True. O DataStateBehavior diz ao VisualStatemanager para ir para o estado relevante.
Assim:
<Button...>
<i:Interaction.Behaviors>
<id:DataStateBehavior Binding="{Binding Selected}" Value="True" TrueState="SelectedVisualState" FalseState="DeselectedVisualState"/>
</i:Interaction.Behaviors>
</Button>
O acima funciona bem. O que estou tentando fazer é que ele defina o estado correto quando o aplicativo carregar, se eu definir a propriedade 'selecionada' no modelo de exibição como true por padrão, eu não veria nenhuma alteração na interface do usuário até Cliquei no botão para alterar a propriedade ViewModel.
Eu sei que existem várias classes envolvidas com as coisas de dados, incluindo:
- BindingListener.cs
- Converterhelper.cs
- DataStateBeHavior.cs
- Datastateswitchbehavior.cs
- Datatrigger.cs
Qualquer pista seria boa, obrigado
Solução
Na verdade, vou adicionar uma segunda resposta que acabei de experimentar e parece ser mais limpa, pois pode ser feita tudo no XAML e sem um comportamento personalizado. Vou deixar a outra resposta como uma referência para uma solução alternativa, pois ambos funcionam.
<i:Interaction.Triggers>
<i:EventTrigger EventName="Loaded">
<ic:GoToStateAction StateName="SelectedVisualState"/>
</i:EventTrigger>
</i:Interaction.Triggers>
Você só precisará adicionar uma referência ao Microsoft.Expression.Interrações Assembly que faz parte do SDK Blend.
xmlns:ic="clr-namespace:Microsoft.Expression.Interactivity.Core;assembly=Microsoft.Expression.Interactions"
Outras dicas
Experimente esta extensão da classe DataStateBeHavior. Quando o elemento de destino carrega, o DataStateBeHavior será avaliado como se a propriedade fosse atualizada.
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Windows;
namespace Gusdor.Wpf
{
/// <summary>
/// Fix for data state behavior. Behavior will trigger transitions when target element loads.
/// </summary>
class DataStateBehaviorFix: Microsoft.Expression.Interactivity.Core.DataStateBehavior
{
public bool UseTransitionsOnLoad { get; set; }
protected override void OnAttached()
{
base.OnAttached();
AssociatedObject.Loaded += AssociatedObject_Loaded;
}
protected override void OnDetaching()
{
base.OnDetaching();
AssociatedObject.Loaded -= AssociatedObject_Loaded;
}
void AssociatedObject_Loaded(object sender, System.Windows.RoutedEventArgs e)
{
Evaluate();
}
void Evaluate()
{
if (Value == null)
{
GotoState(Binding == null, this.AssociatedObject);
}
else GotoState(Value.Equals(Binding), this.AssociatedObject);
}
/// <summary>
/// Attempts to change to the named state. Walks up tree to first match.
/// </summary>
/// <param name="flag"></param>
/// <param name="element"></param>
void GotoState(bool flag, FrameworkElement element)
{
string stateName = flag ? TrueState : FalseState;
if (HasState(element, stateName))
{
bool ret = System.Windows.VisualStateManager.GoToElementState(element, stateName, UseTransitionsOnLoad);
}
else if (element.Parent as FrameworkElement != null)
GotoState(flag, element.Parent as FrameworkElement);
}
/// <summary>
/// Checks if an element has the state named
/// </summary>
/// <param name="element"></param>
/// <param name="stateName"></param>
/// <returns></returns>
bool HasState(FrameworkElement element, string stateName)
{
var groups = Microsoft.Expression.Interactivity.VisualStateUtilities.GetVisualStateGroups(element).Cast<VisualStateGroup>();
return groups.Any(p => p.States.Cast<VisualState>().Any(s => s.Name == stateName));
}
}
}
Uma maneira de resolver esse problema é fazer um comportamento que você pode adicionar ao seu controle para colocá -lo em um estado visual inicial após o carregamento. Aqui está um exemplo simples:
public class InitialVisualStateBehavior : Behavior<Control>
{
public static readonly DependencyProperty InitialStateProperty = DependencyProperty.Register(
"InitialState",
typeof(string),
typeof(InitialVisualStateBehavior),
null);
public string InitialState
{
get { return (string)GetValue(InitialStateProperty); }
set { SetValue(InitialStateProperty, value); }
}
protected override void OnAttached()
{
base.OnAttached();
if (this.AssociatedObject != null)
{
this.AssociatedObject.Loaded += new RoutedEventHandler(AssociatedObject_Loaded);
}
}
protected override void OnDetaching()
{
base.OnDetaching();
if (this.AssociatedObject != null)
{
this.AssociatedObject.Loaded -= AssociatedObject_Loaded;
}
}
private void AssociatedObject_Loaded(object sender, RoutedEventArgs e)
{
VisualStateManager.GoToState(this.AssociatedObject, this.InitialState, false);
}
}
Você então adicionaria esse comportamento ao nível do UserControl em XAML:
<i:Interaction.Behaviors>
<myi:InitialVisualStateBehavior InitialState="SelectedVisualState" />
</i:Interaction.Behaviors>
Você também pode modificar facilmente isso para aceitar uma lista separada por vírgula dos estados iniciais, que você poderia dividir e percorrer se precisar colocar o controle em um monte de diferentes estados mutuamente exclusivos após o carregamento.
Isso também pode ser refaturado em um triggeraction que você pode simplesmente desencadear do evento carregado do controle, não tenho certeza de que caminho seria mais limpo.