Définir le focus sur la zone de texte dans WPF de la vue modèle

Je sais que cette question a été répondu mille fois plus maintenant, mais j'ai fait quelques modifications pour Anvaka contribution qui je pense va aider d'autres personnes qui avaient le même problème que j'avais.

Tout d'abord, j'ai changé le au-dessus de la Propriété Attachée de la sorte:

public static class FocusExtension
{
public static readonly DependencyProperty IsFocusedProperty = 
DependencyProperty.RegisterAttached("IsFocused", typeof(bool?), typeof(FocusExtension), new FrameworkPropertyMetadata(IsFocusedChanged){BindsTwoWayByDefault = true});
public static bool? GetIsFocused(DependencyObject element)
{
if (element == null)
{
throw new ArgumentNullException("element");
}
return (bool?)element.GetValue(IsFocusedProperty);
}
public static void SetIsFocused(DependencyObject element, bool? value)
{
if (element == null)
{
throw new ArgumentNullException("element");
}
element.SetValue(IsFocusedProperty, value);
}
private static void IsFocusedChanged(DependencyObject d, DependencyPropertyChangedEventArgs e)
{
var fe = (FrameworkElement)d;
if (e.OldValue == null)
{
fe.GotFocus += FrameworkElement_GotFocus;
fe.LostFocus += FrameworkElement_LostFocus;
}
if (!fe.IsVisible)
{
fe.IsVisibleChanged += new DependencyPropertyChangedEventHandler(fe_IsVisibleChanged);
}
if ((bool)e.NewValue)
{
fe.Focus();
}
}
private static void fe_IsVisibleChanged(object sender, DependencyPropertyChangedEventArgs e)
{
var fe = (FrameworkElement)sender;
if (fe.IsVisible && (bool)((FrameworkElement)sender).GetValue(IsFocusedProperty))
{
fe.IsVisibleChanged -= fe_IsVisibleChanged;
fe.Focus();
}
}
private static void FrameworkElement_GotFocus(object sender, RoutedEventArgs e)
{
((FrameworkElement)sender).SetValue(IsFocusedProperty, true);
}
private static void FrameworkElement_LostFocus(object sender, RoutedEventArgs e)
{
((FrameworkElement)sender).SetValue(IsFocusedProperty, false);
}
}

Ma raison de l'ajout de la visibilité des références ont été onglets. Apparemment, si vous avez utilisé la propriété attachée sur un autre onglet en dehors de la initialement visible de l'onglet, la propriété attachée à ne pas travailler jusqu'à ce que vous porté manuellement le contrôle.

L'autre obstacle était de créer un moyen plus élégant de la réinitialisation de la propriété sous-jacente à false quand il a perdu le focus. C'est là que le foyer perdu événements sont arrivés.

<TextBox            
Text="{Binding Description}"
FocusExtension.IsFocused="{Binding IsFocused}"/>

Si il y a une meilleure façon de gérer la visibilité de la question, s'il vous plaît laissez-moi savoir.

Note: Grâce à Apfelkuacha pour la suggestion de mettre le BindsTwoWayByDefault dans le DependencyProperty. J'avais fait cela il y a longtemps dans mon propre code, mais jamais mis à jour ce post. Le Mode=TwoWay n'est plus nécessaire dans le code WPF en raison de ce changement.

Aucun de ces fonctionné pour moi, mais pour le bénéfice des autres, c'est ce que j'ai fini par écrire basé sur le code déjà fourni ici.

D'utilisation serait comme suit:

<TextBox ... h:FocusBehavior.IsFocused="True"/>

Et la mise en œuvre serait comme suit:

///<summary>
///Behavior allowing to put focus on element from the view model in a MVVM implementation.
///</summary>
public static class FocusBehavior
{
#region Dependency Properties
///<summary>
///<c>IsFocused</c> dependency property.
///</summary>
public static readonly DependencyProperty IsFocusedProperty =
DependencyProperty.RegisterAttached("IsFocused", typeof(bool?),
typeof(FocusBehavior), new FrameworkPropertyMetadata(IsFocusedChanged));
///<summary>
///Gets the <c>IsFocused</c> property value.
///</summary>
///<param name="element">The element.</param>
///<returns>Value of the <c>IsFocused</c> property or <c>null</c> if not set.</returns>
public static bool? GetIsFocused(DependencyObject element)
{
if (element == null)
{
throw new ArgumentNullException("element");
}
return (bool?)element.GetValue(IsFocusedProperty);
}
///<summary>
///Sets the <c>IsFocused</c> property value.
///</summary>
///<param name="element">The element.</param>
///<param name="value">The value.</param>
public static void SetIsFocused(DependencyObject element, bool? value)
{
if (element == null)
{
throw new ArgumentNullException("element");
}
element.SetValue(IsFocusedProperty, value);
}
#endregion Dependency Properties
#region Event Handlers
///<summary>
///Determines whether the value of the dependency property <c>IsFocused</c> has change.
///</summary>
///<param name="d">The dependency object.</param>
///<param name="e">The <see cref="System.Windows.DependencyPropertyChangedEventArgs"/> instance containing the event data.</param>
private static void IsFocusedChanged(DependencyObject d, DependencyPropertyChangedEventArgs e)
{
//Ensure it is a FrameworkElement instance.
var fe = d as FrameworkElement;
if (fe != null && e.OldValue == null && e.NewValue != null && (bool)e.NewValue)
{
//Attach to the Loaded event to set the focus there. If we do it here it will
//be overridden by the view rendering the framework element.
fe.Loaded += FrameworkElementLoaded;
}
}
///<summary>
///Sets the focus when the framework element is loaded and ready to receive input.
///</summary>
///<param name="sender">The sender.</param>
///<param name="e">The <see cref="System.Windows.RoutedEventArgs"/> instance containing the event data.</param>
private static void FrameworkElementLoaded(object sender, RoutedEventArgs e)
{
//Ensure it is a FrameworkElement instance.
var fe = sender as FrameworkElement;
if (fe != null)
{
//Remove the event handler registration.
fe.Loaded -= FrameworkElementLoaded;
//Set the focus to the given framework element.
fe.Focus();
//Determine if it is a text box like element.
var tb = fe as TextBoxBase;
if (tb != null)
{
//Select all text to be ready for replacement.
tb.SelectAll();
}
}
}
#endregion Event Handlers
}

Dans mon cas, le FocusExtension n'a pas fonctionné jusqu'à ce que je change la méthode OnIsFocusedPropertyChanged. L'original a été de travailler uniquement dans le débogage lors d'un point de rupture arrêté le processus. Au moment de l'exécution, le processus est trop rapide et rien ne s'est vraiment passé. Avec cette petite modification et à l'aide de notre ami Tâche, cela fonctionne bien dans les deux scénarios.

private static void OnIsFocusedPropertyChanged(DependencyObject d, DependencyPropertyChangedEventArgs e)
{
var uie = (UIElement)d;
if ((bool)e.NewValue)
{
var action = new Action(() => uie.Dispatcher.BeginInvoke((Action)(() => uie.Focus())));
Task.Factory.StartNew(action);
}
}

Le problème est qu'une fois le IsUserNameFocused est défini sur true, il ne sera jamais faux. Cela résout par la manipulation de la GotFocus et LostFocus FrameworkElement.

J'ai eu du mal avec la source de formatage de code voici donc une lien

- Je utiliser WPF /Caliburn Micro a constaté que "dfaivre" a fait un général et solution viable
ici:
http://caliburnmicro.codeplex.com/discussions/222892

Pour Silverlight:

using System.Windows;
using System.Windows.Controls;
using System.Windows.Interactivity;
namespace MyProject.Behaviors
{
public class FocusBehavior : Behavior<Control>
{
protected override void OnAttached()
{
this.AssociatedObject.Loaded += AssociatedObject_Loaded;
base.OnAttached();
}
private void AssociatedObject_Loaded(object sender, RoutedEventArgs e)
{
this.AssociatedObject.Loaded -= AssociatedObject_Loaded;
if (this.HasInitialFocus || this.IsFocused)
{
this.GotFocus();
}
}
private void GotFocus()
{
this.AssociatedObject.Focus();
if (this.IsSelectAll)
{
if (this.AssociatedObject is TextBox)
{
(this.AssociatedObject as TextBox).SelectAll();
}
else if (this.AssociatedObject is PasswordBox)
{
(this.AssociatedObject as PasswordBox).SelectAll();
}
else if (this.AssociatedObject is RichTextBox)
{
(this.AssociatedObject as RichTextBox).SelectAll();
}
}
}
public static readonly DependencyProperty IsFocusedProperty =
DependencyProperty.Register(
"IsFocused",
typeof(bool),
typeof(FocusBehavior),
new PropertyMetadata(false, 
(d, e) => 
{
if ((bool)e.NewValue)
{
((FocusBehavior)d).GotFocus();
}
}));
public bool IsFocused
{
get { return (bool)GetValue(IsFocusedProperty); }
set { SetValue(IsFocusedProperty, value); }
}
public static readonly DependencyProperty HasInitialFocusProperty =
DependencyProperty.Register(
"HasInitialFocus",
typeof(bool),
typeof(FocusBehavior),
new PropertyMetadata(false, null));
public bool HasInitialFocus
{
get { return (bool)GetValue(HasInitialFocusProperty); }
set { SetValue(HasInitialFocusProperty, value); }
}
public static readonly DependencyProperty IsSelectAllProperty =
DependencyProperty.Register(
"IsSelectAll",
typeof(bool),
typeof(FocusBehavior),
new PropertyMetadata(false, null));
public bool IsSelectAll
{
get { return (bool)GetValue(IsSelectAllProperty); }
set { SetValue(IsSelectAllProperty, value); }
}
}
}

LoginViewModel.cs:

    public class LoginModel : ViewModelBase
{
....
private bool _EmailFocus = false;
public bool EmailFocus
{
get
{
return _EmailFocus;
}
set
{
if (value)
{
_EmailFocus = false;
RaisePropertyChanged("EmailFocus");
}
_EmailFocus = value;
RaisePropertyChanged("EmailFocus");
}
}
...
}

De connexion.xaml:

xmlns:i="http://schemas.microsoft.com/expression/2010/interactivity"
xmlns:beh="clr-namespace:MyProject.Behaviors"
<TextBox Text="{Binding Email, Mode=TwoWay, UpdateSourceTrigger=PropertyChanged}">
<i:Interaction.Behaviors>
<beh:FocusBehavior IsFocused="{Binding EmailFocus}" IsSelectAll="True"/>
</i:Interaction.Behaviors>
</TextBox>

OU

<TextBox Text="{Binding Email, Mode=TwoWay, UpdateSourceTrigger=PropertyChanged}">
<i:Interaction.Behaviors>
<beh:FocusBehavior HasInitialFocus="True" IsSelectAll="True"/>
</i:Interaction.Behaviors>
</TextBox>

Pour définir le focus doit juste le faire dans le code:

EmailFocus = true;

Oubliez pas que ce plugin est une partie d'une page html, de sorte que d'autres contrôles dans la page peut avoir le focus

if (!Application.Current.IsRunningOutOfBrowser)
{
System.Windows.Browser.HtmlPage.Plugin.Focus();
}

Tout d'abord je tiens à remercier Avanka pour m'aider à résoudre mon problème de focus. Il y a cependant un bug dans le code, il a affiché, à savoir dans la ligne:
si (e.OldValue == null)

Le problème que j'avais était que si vous cliquez d'abord dans votre point de vue et de se concentrer le contrôle, l'e.oldValue n'est plus nulle. Ensuite, lorsque vous définissez la variable de concentrer le contrôle pour la première fois, cette résultats dans la perte focus et gotfocus gestionnaires de ne pas être ensemble.
Ma solution à ce problème est comme suit:

public static class ExtensionFocus
{
static ExtensionFocus()
{
BoundElements = new List<string>();
}
public static readonly DependencyProperty IsFocusedProperty =
DependencyProperty.RegisterAttached("IsFocused", typeof(bool?),
typeof(ExtensionFocus), new FrameworkPropertyMetadata(false, IsFocusedChanged));
private static List<string> BoundElements;
public static bool? GetIsFocused(DependencyObject element)
{
if (element == null)
{
throw new ArgumentNullException("ExtensionFocus GetIsFocused called with null element");
}
return (bool?)element.GetValue(IsFocusedProperty);
}
public static void SetIsFocused(DependencyObject element, bool? value)
{
if (element == null)
{
throw new ArgumentNullException("ExtensionFocus SetIsFocused called with null element");
}
element.SetValue(IsFocusedProperty, value);
}
private static void IsFocusedChanged(DependencyObject d, DependencyPropertyChangedEventArgs e)
{
var fe = (FrameworkElement)d;
//OLD LINE:
//if (e.OldValue == null)
//TWO NEW LINES:
if (BoundElements.Contains(fe.Name) == false)
{
BoundElements.Add(fe.Name);
fe.LostFocus += OnLostFocus;
fe.GotFocus += OnGotFocus;
}           
if (!fe.IsVisible)
{
fe.IsVisibleChanged += new DependencyPropertyChangedEventHandler(fe_IsVisibleChanged);
}
if ((bool)e.NewValue)
{
fe.Focus();             
}
}
private static void fe_IsVisibleChanged(object sender, DependencyPropertyChangedEventArgs e)
{
var fe = (FrameworkElement)sender;
if (fe.IsVisible && (bool)((FrameworkElement)sender).GetValue(IsFocusedProperty))
{
fe.IsVisibleChanged -= fe_IsVisibleChanged;
fe.Focus();
}
}
private static void OnLostFocus(object sender, RoutedEventArgs e)
{
if (sender != null && sender is Control s)
{
s.SetValue(IsFocusedProperty, false);
}
}
private static void OnGotFocus(object sender, RoutedEventArgs e)
{
if (sender != null && sender is Control s)
{
s.SetValue(IsFocusedProperty, true);
}
}
}

Une approche alternative fondée sur @Sheridan réponse ici

 <TextBox Text="{Binding SomeText, Mode=TwoWay, UpdateSourceTrigger=PropertyChanged}">
<TextBox.Style>
<Style>
<Style.Triggers>
<DataTrigger Binding="{Binding SomeTextIsFocused, Mode=TwoWay, UpdateSourceTrigger=PropertyChanged}" Value="True">
<Setter Property="FocusManager.FocusedElement" Value="{Binding RelativeSource={RelativeSource Self}}" />
</DataTrigger>
</Style.Triggers>
</Style>
</TextBox.Style>
</TextBox>

Dans votre modèle d'affichage configurer votre liaison dans la façon habituelle, puis définissez la SomeTextIsFocused à true pour définir le focus sur la zone de texte

public class DummyViewModel : ViewModelBase
{
private bool isfocused= false;
public bool IsFocused
{
get
{
return isfocused;
}
set
{
isfocused= value;
OnPropertyChanged("IsFocused");
}
}
}

Viens de le faire:

<Window x:class...
...
...
FocusManager.FocusedElement="{Binding ElementName=myTextBox}"
>
<Grid>
<TextBox Name="myTextBox"/>
...