Déterminer si la touche Entrée a été enfoncée dans un TextBox

Question

Considérons une TextBox XAML dans Win Phone 7.

  <TextBox x:Name="UserNumber"   />

L'objectif ici est que lorsque l'utilisateur appuie sur la touche Enter sur le clavier à l'écran, cela déclencherait une certaine logique pour rafraîchir le contenu à l'écran.

J'aimerais qu'un événement soit organisé spécifiquement pour Enter . Est-ce possible ?

• L'événement est-il spécifique à la TextBox, ou s'agit-il d'un événement clavier système ?
• Faut-il un chèque pour le Enter à chaque pression sur une touche ? c'est-à-dire une analogie avec l'ASCII 13 ?
• Quelle est la meilleure façon de codifier cette exigence ?

Answer 1

Une approche directe pour cela dans une zone de texte est la suivante

private void textBox1_KeyDown(object sender, KeyEventArgs e)
{
    if (e.Key == Key.Enter)
    {
        Debug.WriteLine("Enter");
    }
}

Answer 2

Vous devrez implémenter l'événement KeyDown spécifique à cette zone de texte, et vérifier dans les KeyEventArgs la touche pressée (et si elle correspond à Key.Enter, faire quelque chose).

<TextBox Name="Box" InputScope="Text" KeyDown="Box_KeyDown"></TextBox>

private void Box_KeyDown(object sender, KeyEventArgs e)
{
    if (e.Key.Equals(Key.Enter))
    {
        //Do something
    }
}

Notez que dans la version bêta de l'émulateur WP7, bien que l'utilisation du clavier logiciel à l'écran détecte correctement la touche Entrée, si vous utilisez le clavier matériel (activé en appuyant sur Pause/Break), la touche Entrée semble être identifiée comme Key.Unknown - ou du moins, c'était le cas sur mon ordinateur...

Answer 3

Si vous ne voulez pas ajouter de code dans le fichier de code de votre XAML et garder votre conception propre du point de vue de l'architecture MVVM, vous pouvez utiliser l'approche suivante. Dans votre XAML, définissez votre commande en binding comme ceci :

 <TextBox 
Text="{Binding Text}" 
custom:KeyUp.Command="{Binding Path=DataContext.DoCommand, ElementName=root}" />

où KeyUp classe :

using System.Windows;
using System.Windows.Controls;
using System.Windows.Input;

namespace PhoneGuitarTab.Controls
{
    public static class KeyUp
    {
        private static readonly DependencyProperty KeyUpCommandBehaviorProperty = DependencyProperty.RegisterAttached(
            "KeyUpCommandBehavior",
            typeof(TextBoxCommandBehavior),
            typeof(KeyUp),
            null);

        /// 
        /// Command to execute on KeyUp event.
        /// 
        public static readonly DependencyProperty CommandProperty = DependencyProperty.RegisterAttached(
            "Command",
            typeof(ICommand),
            typeof(KeyUp),
            new PropertyMetadata(OnSetCommandCallback));

        /// 
        /// Command parameter to supply on command execution.
        /// 
        public static readonly DependencyProperty CommandParameterProperty = DependencyProperty.RegisterAttached(
            "CommandParameter",
            typeof(object),
            typeof(KeyUp),
            new PropertyMetadata(OnSetCommandParameterCallback));

        /// 
        /// Sets the  to execute on the KeyUp event.
        /// 
        /// TextBox dependency object to attach command
        /// Command to attach
        \[System.Diagnostics.CodeAnalysis.SuppressMessage("Microsoft.Design", "CA1011:ConsiderPassingBaseTypesAsParameters", Justification = "Only works for buttonbase")\]
        public static void SetCommand(TextBox textBox, ICommand command)
        {
            textBox.SetValue(CommandProperty, command);
        }

        /// 
        /// Retrieves the  attached to the .
        /// 
        /// TextBox containing the Command dependency property
        /// The value of the command attached
        \[System.Diagnostics.CodeAnalysis.SuppressMessage("Microsoft.Design", "CA1011:ConsiderPassingBaseTypesAsParameters", Justification = "Only works for buttonbase")\]
        public static ICommand GetCommand(TextBox textBox)
        {
            return textBox.GetValue(CommandProperty) as ICommand;
        }

        /// 
        /// Sets the value for the CommandParameter attached property on the provided .
        /// 
        /// TextBox to attach CommandParameter
        /// Parameter value to attach
        \[System.Diagnostics.CodeAnalysis.SuppressMessage("Microsoft.Design", "CA1011:ConsiderPassingBaseTypesAsParameters", Justification = "Only works for buttonbase")\]
        public static void SetCommandParameter(TextBox textBox, object parameter)
        {
            textBox.SetValue(CommandParameterProperty, parameter);
        }

        /// 
        /// Gets the value in CommandParameter attached property on the provided 
        /// 
        /// TextBox that has the CommandParameter
        /// The value of the property
        \[System.Diagnostics.CodeAnalysis.SuppressMessage("Microsoft.Design", "CA1011:ConsiderPassingBaseTypesAsParameters", Justification = "Only works for buttonbase")\]
        public static object GetCommandParameter(TextBox textBox)
        {
            return textBox.GetValue(CommandParameterProperty);
        }

        private static void OnSetCommandCallback(DependencyObject dependencyObject, DependencyPropertyChangedEventArgs e)
        {
            TextBox textBox = dependencyObject as TextBox;
            if (textBox != null)
            {
                TextBoxCommandBehavior behavior = GetOrCreateBehavior(textBox);
                behavior.Command = e.NewValue as ICommand;
            }
        }

        private static void OnSetCommandParameterCallback(DependencyObject dependencyObject, DependencyPropertyChangedEventArgs e)
        {
            TextBox textBox = dependencyObject as TextBox;
            if (textBox != null)
            {
                TextBoxCommandBehavior behavior = GetOrCreateBehavior(textBox);
                behavior.CommandParameter = e.NewValue;
            }
        }

        private static TextBoxCommandBehavior GetOrCreateBehavior(TextBox textBox)
        {
            TextBoxCommandBehavior behavior = textBox.GetValue(KeyUpCommandBehaviorProperty) as TextBoxCommandBehavior;
            if (behavior == null)
            {
                behavior = new TextBoxCommandBehavior(textBox);
                textBox.SetValue(KeyUpCommandBehaviorProperty, behavior);
            }

            return behavior;
        }
    }
}

La classe en utilise d'autres, alors je les fournis aussi. TextBoxCommandBehavior classe :

using System;
using System.Windows.Controls;
using System.Windows.Input;

namespace PhoneGuitarTab.Controls
{
    public class TextBoxCommandBehavior : CommandBehaviorBase
    {
        public TextBoxCommandBehavior(TextBox textBoxObject)
            : base(textBoxObject)
        {
            textBoxObject.KeyUp += (s, e) =>
                                       {
                                           string input = (s as TextBox).Text;
                                           //TODO validate user input here
                                           \*\*//ENTER IS PRESSED!\*\*
                                           if ((e.Key == Key.Enter) 
                                               && (!String.IsNullOrEmpty(input)))
                                           {
                                               this.CommandParameter = input;
                                               ExecuteCommand();
                                           }
                                       };

        }
    }
}

CommandBehaviorBase classe :

using System;
using System.Windows.Controls;
using System.Windows.Input;

namespace PhoneGuitarTab.Controls
{
    /// 
    /// Base behavior to handle connecting a  to a Command.
    /// 
    /// The target object must derive from Control
    /// 
    /// CommandBehaviorBase can be used to provide new behaviors similar to .
    /// 
    public class CommandBehaviorBase
                where T : Control
    {
        private ICommand command;
        private object commandParameter;
        private readonly WeakReference targetObject;
        private readonly EventHandler commandCanExecuteChangedHandler;

        /// 
        /// Constructor specifying the target object.
        /// 
        /// The target object the behavior is attached to.
        public CommandBehaviorBase(T targetObject)
        {
            this.targetObject = new WeakReference(targetObject);
            this.commandCanExecuteChangedHandler = new EventHandler(this.CommandCanExecuteChanged);
        }

        /// 
        /// Corresponding command to be execute and monitored for 
        /// 
        public ICommand Command
        {
            get { return command; }
            set
            {
                if (this.command != null)
                {
                    this.command.CanExecuteChanged -= this.commandCanExecuteChangedHandler;
                }

                this.command = value;
                if (this.command != null)
                {
                    this.command.CanExecuteChanged += this.commandCanExecuteChangedHandler;
                    UpdateEnabledState();
                }
            }
        }

        /// 
        /// The parameter to supply the command during execution
        /// 
        public object CommandParameter
        {
            get { return this.commandParameter; }
            set
            {
                if (this.commandParameter != value)
                {
                    this.commandParameter = value;
                    this.UpdateEnabledState();
                }
            }
        }

        /// 
        /// Object to which this behavior is attached.
        /// 
        protected T TargetObject
        {
            get
            {
                return targetObject.Target as T;
            }
        }

        /// 
        /// Updates the target object's IsEnabled property based on the commands ability to execute.
        /// 
        protected virtual void UpdateEnabledState()
        {
            if (TargetObject == null)
            {
                this.Command = null;
                this.CommandParameter = null;
            }
            else if (this.Command != null)
            {
                TargetObject.IsEnabled = this.Command.CanExecute(this.CommandParameter);
            }
        }

        private void CommandCanExecuteChanged(object sender, EventArgs e)
        {
            this.UpdateEnabledState();
        }

        /// 
        /// Executes the command, if it's set, providing the 
        /// 
        protected virtual void ExecuteCommand()
        {
            if (this.Command != null)
            {
                this.Command.Execute(this.CommandParameter);
            }
        }
    }
}

Vous pouvez trouver l'exemple fonctionnel sur mon projet open source ( PhoneGuitarTab.Controls projet en solution) : http://phoneguitartab.codeplex.com

Answer 4

Si vous utilisez l'émulateur, vous pouvez également faire quelque chose comme ceci pour détecter la touche Entrée de votre clavier physique.

    private void textBox1_KeyUp(object sender, KeyEventArgs e) {
        var isEnterKey =
            e.Key == System.Windows.Input.Key.Enter ||
            e.PlatformKeyCode == 10;

        if (isEnterKey) {
            // ...
        }
    }

Answer 5

Désactiver le clavier

J'ai été confronté au même problème ; les exemples ci-dessus ne donnent que des détails sur les éléments suivants comment capturer l'événement de pression du clavier (ce qui répond à la question), mais pour mais pour désactiver le clavier, lors d'un clic ou d'une entrée, il suffit que le focus soit placé sur un autre contrôle.

Ce qui aura pour effet de désactiver le clavier.

private void txtCodeText_KeyDown(object sender, KeyEventArgs e)
{
    if(e.Key.Equals(Key.Enter))
    {
        //setting the focus to different control
        btnTransmit.Focus();
    }
}