Zone de texte LostFocus ne se pose pas lorsque l'on clique sur certains autres contrôles

Dans la suite de la simple application WPF une TextBox est configuré pour mettre à jour une propriété lorsque le focus est perdu à partir de ce contrôle, comme

<DockPanel>
    <ToolBar DockPanel.Dock="Top">
        <Button>Test</Button>
    </ToolBar>
    <TextBox Text="{Binding MyString}" />
</DockPanel>

public MainWindow()
{
    InitializeComponent();
    DataContext = this;
}

public string MyString
{
    get { return _myString; }
    set { _myString = value; }
}

Cependant quand je lance cette application, entrez du texte dans la zone de texte, puis cliquez sur le bouton "Test" de mon point d'arrêt sur la MyString propriété est pas soulevées, aussi tout gestionnaire d'événements pour l' FocusLost événement n'est pas déclenché. Ces événements ne sont soulevées lorsque le focus est perdu à partir du contrôle par d'autres moyens (par exemple, la fenêtre est fermée).

C'est à l'origine des problèmes pour nous que dans la réalité le bouton "Test" contient la logique qui s'appuie sur la MyString propriété d'être mis à jour.

Comment puis-je m'assurer que le FocusLost événement est correctement soulevée et que la liaison est mise à jour lorsque je clique sur le bouton "Test"? Il semble que le problème est en quelque sorte causé par l'utilisation de la ToolBar, que le remplacement de la ToolBar avec un bouton standard n'a pas pour conséquence de ce comportement.

OriginalL'auteur Justin | 2013-06-04

Dans ce cas, la zone de texte n'a pas de lâche le focus logique et si l'événement n'est jamais soulevée - en fait, j'ai réellement envie de la LostKeyboardFocus événement, et non pas le LostFocus événement pour déclencher la mise à jour.

Ce problème est similaire à WPF: Données lié TabControl ne pas valider les modifications lorsque nouvel onglet est sélectionné et Microsoft a un élément de connexion pour elle ici avec un certain nombre de solutions possibles, cependant j'ai fixé ce, à l'aide d'une propriété attachée comme si.

public static readonly DependencyProperty BindOnLostKeyboardFocusProperty =
    DependencyProperty.RegisterAttached("BindOnLostKeyboardFocus", typeof(bool), typeof(MainWindow), new PropertyMetadata(default(bool), BindOnLostKeyboardFocusChanged));

private static void BindOnLostKeyboardFocusChanged(DependencyObject o, DependencyPropertyChangedEventArgs e)
{
    var control = o as UIElement;
    if (control != null)
    {
        if ((bool) e.NewValue)
        {
            control.AddHandler(LostKeyboardFocusEvent, new RoutedEventHandler(ControlLostKeyboardFocus));
        }
        else
        {
            control.RemoveHandler(LostKeyboardFocusEvent, new RoutedEventHandler(ControlLostKeyboardFocus));
        }
    }
}

private static void ControlLostKeyboardFocus(object sender, RoutedEventArgs e)
{
    var control = (UIElement)sender;
    control.RaiseEvent(new RoutedEventArgs(LostFocusEvent));
}

Cela signifie que chaque fois que LostKeyboardFocus est soulevé pour ce contrôle, il va de l'avant et soulève un supplément de LostFocus événement à l'origine de la liaison de mise à jour. Il est utilisé comme

<TextBox Text="{Binding Test}" LostKeyboardFocus="UIElement_OnLostKeyboardFocus" local:MainWindow.BindOnLostKeyboardFocus="True" />

OriginalL'auteur Justin

2

De votre propriété fait une couple d'hypothèses:
- que rien n'est en fonction de la distinction entre le LostKeyboardFocus et LostFocus événements
- que les liaisons sur l'élément auquel il est rattaché répondra véritablement à la LostFocus événement (ils pourraient avoir UpdateSourceTrigger.Explicite)
Au lieu de cela, vous pourriez énumérer les liaisons sur l'élément et d'appeler directement le UpdateSource:
```
private void CommitBindings(DependencyObject element) {
    var localValueEnumerator = element.GetLocalValueEnumerator();
    while (localValueEnumerator.MoveNext()) {
        var entry = localValueEnumerator.Current;
        if (BindingOperations.IsDataBound(element, entry.Property)) {
            var bindingExpression = (BindingExpressionBase)entry.Value;
            bindingExpression.UpdateSource();
        }
    }
}
```
Aussi, au lieu de traiter chaque TextBox individuellement, vous pouvez gérer le conteneur et l'utilisation OldFocus d'obtenir le véritable élément qui a perdu le focus du clavier.

OriginalL'auteur nmclean

Le problème suivant va résoudre ce problème:

public class TextBoxUpdateOnLostKeyboardFocusBehavior : Behavior<TextBox>
{
    protected override void OnAttached()
    {
        if (AssociatedObject != null)
        {
            base.OnAttached();
            AssociatedObject.LostKeyboardFocus += OnKeyboardLostFocus;
        }
    }

    protected override void OnDetaching()
    {
        if (AssociatedObject != null)
        {
            AssociatedObject.LostKeyboardFocus -= OnKeyboardLostFocus;
            base.OnDetaching();
        }
    }

    private void OnKeyboardLostFocus(object sender, KeyboardFocusChangedEventArgs e)
    {
        var textBox = sender as TextBox;

        if (textBox != null && e.NewFocus == null)
        {
            //Focus on the closest focusable ancestor
            FrameworkElement parent = (FrameworkElement) textBox.Parent;
            while (parent is IInputElement && !((IInputElement) parent).Focusable)
            {
                parent = (FrameworkElement) parent.Parent;
            }

            DependencyObject scope = FocusManager.GetFocusScope(textBox);
            FocusManager.SetFocusedElement(scope, parent);
        }
    }
}

Vous pouvez l'attacher à votre zone de texte comme suit:

        <TextBox>
            <i:Interaction.Behaviors>
                <behaviors1:TextBoxUpdateOnLostKeyboardFocusBehavior />
            </i:Interaction.Behaviors>              
        </TextBox>

OriginalL'auteur Matt Sinclair

Vous devez vous connecter pour publier un commentaire.