Déterminer la touche Entrée est enfoncé dans une zone de texte

Considérons une zone de texte XAML dans Win Phone 7.

 

L’objective est que lorsque l’utilisateur appuie sur le bouton Enter du clavier virtuel, cela déclenche une logique pour actualiser le contenu à l’écran.

Je voudrais avoir un événement soulevé spécifiquement pour Enter . Est-ce possible?

  • L’événement est-il spécifique à la zone de texte ou s’agit-il d’un événement de clavier système?
  • Est-ce qu’il faut vérifier l’ Enter sur chaque touche? c.-à-d. certains analogiques à ASCII 13?
  • Quelle est la meilleure façon de coder cette exigence?

texte alt

Une approche simple pour cela dans une zone de texte est

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

Vous chercherez à implémenter l’événement KeyDown spécifique à cette zone de texte, et à vérifier la KeyEventArgs pour la touche réelle pressée (et si elle correspond à Key.Enter, faites quelque chose)

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

Juste une note que dans la version bêta de l’émulateur WP7, bien que l’utilisation du clavier logiciel détecte la touche Entrée correctement, si vous utilisez le clavier matériel (activé en appuyant sur Pause / Pause), la touche Entrée semble venir à travers comme Key.Unknown – ou du moins, il le faisait sur mon ordinateur …

Si vous ne souhaitez pas append de code au code de votre fichier XAML derrière votre fichier et que vous ne modifiez pas le point d’architecture MVVM, vous pouvez utiliser l’approche suivante. Dans votre XAML, définissez votre commande dans la liaison comme ceci:

   

où la classe KeyUp :

  en utilisant System.Windows;
 en utilisant System.Windows.Controls;
 en utilisant System.Windows.Input;

 espace de noms PhoneGuitarTab.Controls
 {
     Classe publique statique KeyUp
     {
         statique privé readonly DependencyProperty KeyUpCommandBehaviorProperty = DependencyProperty.RegisterAttached (
             "KeyUpCommandBehavior",
             typeof (TextBoxCommandBehavior),
             typeof (KeyUp),
             nul);


         /// 
         /// Commande à exécuter sur l'événement KeyUp.
         /// 
         public static readonly DependencyProperty CommandProperty = DependencyProperty.RegisterAttached (
             "Commander",
             typeof (ICommand),
             typeof (KeyUp),
             new PropertyMetadata (OnSetCommandCallback));

         /// 
         /// Paramètre de commande à fournir lors de l'exécution de la commande.
         /// 
         public statique en lecture seule DependencyProperty CommandParameterProperty = DependencyProperty.RegisterAttached (
             "CommandParameter",
             typeof (object),
             typeof (KeyUp),
             nouveau PropertyMetadata (OnSetCommandParameterCallback));


         /// 
         /// Configure l'exécution de l'événement KeyUp.
         /// 
         /// Objet de dépendance TextBox à associer à la commande
         /// Commande à joindre
         [System.Diagnostics.CodeAnalysis.SuppressMessage ("Microsoft.Design", "CA1011: ConsiderPassingBaseTypesAsParameters", Justification = "Ne fonctionne que pour la base")]
         public static void SetCommand (TextBox textBox, commande ICommand)
         {
             textBox.SetValue (CommandProperty, commande);
         }

         /// 
         /// Récupère le attaché au.
         /// 
         /// TextBox contenant la propriété de dépendance Command
         /// La valeur de la commande attachée
         [System.Diagnostics.CodeAnalysis.SuppressMessage ("Microsoft.Design", "CA1011: ConsiderPassingBaseTypesAsParameters", Justification = "Ne fonctionne que pour la base")]
         public statique ICommand GetCommand (TextBox textBox)
         {
             renvoyer textBox.GetValue (CommandProperty) en tant que ICommand;
         }

         /// 
         /// Définit la valeur de la propriété jointe CommandParameter sur le fourni.
         /// 
         /// TextBox pour attacher le paramètre de commande
         /// Valeur du paramètre à attacher
         [System.Diagnostics.CodeAnalysis.SuppressMessage ("Microsoft.Design", "CA1011: ConsiderPassingBaseTypesAsParameters", Justification = "Ne fonctionne que pour la base")]
         public statique void SetCommandParameter (TextBox textBox, paramètre object)
         {
             textBox.SetValue (CommandParameterProperty, paramètre);
         }

         /// 
         /// Obtient la valeur de la propriété jointe CommandParameter sur le 
         /// 
         /// TextBox qui a le paramètre CommandParameter
         /// La valeur de la propriété
         [System.Diagnostics.CodeAnalysis.SuppressMessage ("Microsoft.Design", "CA1011: ConsiderPassingBaseTypesAsParameters", Justification = "Ne fonctionne que pour la base")]
         object statique public GetCommandParameter (TextBox textBox)
         {
             renvoyer textBox.GetValue (CommandParameterProperty);
         }

         void statique privé OnSetCommandCallback (DependencyObject dependencyObject, DependencyPropertyChangedEventArgs e)
         {
             TextBox textBox = dependencyObject comme TextBox;
             if (textBox! = null)
             {
                 Comportement de TextBoxCommandBehavior = GetOrCreateBehavior (textBox);
                 behavior.Command = e.NewValue en tant que ICommand;
             }
         }

         void statique privé OnSetCommandParameterCallback (DependencyObject dependencyObject, DependencyPropertyChangedEventArgs e)
         {
             TextBox textBox = dependencyObject comme TextBox;
             if (textBox! = null)
             {
                 Comportement de TextBoxCommandBehavior = GetOrCreateBehavior (textBox);
                 behavior.CommandParameter = e.NewValue;
             }
         }

         statique statique TextBoxCommandBehavior GetOrCreateBehavior (TextBox textBox)
         {
             Comportement TextBoxCommandBehavior = textBox.GetValue (KeyUpCommandBehaviorProperty) en tant que TextBoxCommandBehavior;
             if (comportement == null)
             {
                 behavior = new TextBoxCommandBehavior (textBox);
                 textBox.SetValue (KeyUpCommandBehaviorProperty, comportement);
             }

             comportement de retour;
         }
     }
 } 

La classe en utilise d’autres, donc je les fournis aussi. Classe TextBoxCommandBehavior :

  en utilisant le système;
 en utilisant System.Windows.Controls;
 en utilisant System.Windows.Input;

 espace de noms PhoneGuitarTab.Controls
 {
     Classe publique TextBoxCommandBehavior: CommandBehaviorBase
     {
         public TextBoxCommandBehavior (TextBox textBoxObject)
             : base (textBoxObject)
         {
             textBoxObject.KeyUp + = (s, e) =>
                                        {
                                            ssortingng input = (s comme TextBox) .Text;
                                            // TODO valide la saisie utilisateur ici
                                            ** // ENTRER EST PRESSÉ! **
                                            if ((e.Key == Key.Enter) 
                                                && (! Ssortingng.IsNullOrEmpty (entrée)))
                                            {
                                                this.CommandParameter = input;
                                                ExecuteCommand ();
                                            }
                                        };

         }
     }
 } 

Classe CommandBehaviorBase :

  en utilisant le système;
 en utilisant System.Windows.Controls;
 en utilisant System.Windows.Input;

 espace de noms PhoneGuitarTab.Controls
 {
     /// 
     /// Comportement de base pour gérer la connexion à une commande.
     /// 
     /// L'object cible doit dériver de Control
     /// 
     /// CommandBehaviorBase peut être utilisé pour fournir de nouveaux comportements similaires à.
     /// 
     classe publique CommandBehaviorBase
                 où T: Contrôle
     {
         commande privée ICommand;
         object privé commandParameter;
         en lecture seule WeakReference targetObject;
         en lecture seule EventHandler commandCanExecuteChangedHandler;


         /// 
         /// Constructeur spécifiant l'object cible.
         /// 
         /// L'object cible auquel le comportement est attaché.
         CommandBehaviorBase public (T targetObject)
         {
             this.targetObject = new WeakReference (targetObject);
             this.commandCanExecuteChangedHandler = new EventHandler (this.CommandCanExecuteChanged);
         }

         /// 
         /// Commande correspondante à exécuter et à surveiller pour 
         /// 
         Commande publique ICommand
         {
             get {return command;  }
             ensemble
             {
                 if (this.command! = null)
                 {
                     this.command.CanExecuteChanged - = this.commandCanExecuteChangedHandler;
                 }

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

         /// 
         /// Le paramètre pour fournir la commande pendant l'exécution
         /// 
         object public CommandParameter
         {
             get {return this.commandParameter;  }
             ensemble
             {
                 if (this.commandParameter! = valeur)
                 {
                     this.commandParameter = valeur;
                     this.UpdateEnabledState ();
                 }
             }
         }

         /// 
         /// Objet auquel ce comportement est attaché.
         /// 
         protégé T TargetObject
         {
             obtenir
             {
                 renvoyer targetObject.Target en tant que T;
             }
         }


         /// 
         /// Met à jour la propriété IsEnabled de l'object cible en fonction de la possibilité d'exécution des commandes.
         /// 
         void virtuel protégé UpdateEnabledState ()
         {
             if (TargetObject == null)
             {
                 this.Command = null;
                 this.CommandParameter = null;
             }
             else if (this.Command! = null)
             {
                 TargetObject.IsEnabled = this.Command.CanExecute (this.CommandParameter);
             }
         }

         void privé CommandCanExecuteChanged (expéditeur d'object, EventArgs e)
         {
             this.UpdateEnabledState ();
         }

         /// 
         /// Exécute la commande, si elle est définie, fournissant le 
         /// 
         void virtuel protégé ExecuteCommand ()
         {
             if (this.Command! = null)
             {
                 this.Command.Execute (this.CommandParameter);
             }
         }
     }
 } 

Vous pouvez trouver l’exemple de travail dans mon projet open source (projet PhoneGuitarTab.Controls en solution): http://phoneguitartab.codeplex.com

Si vous utilisez l’émulateur, vous pouvez également faire quelque chose comme ça 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) { // ... } } 

Désactiver le clavier

A été confronté au même problème; Les exemples ci-dessus ne donnent que des détails sur la manière de piéger l’événement de presse du clavier (qui répond à la question), mais pour désactiver le clavier, cliquez ou entrez, le focus est défini sur un autre contrôle.

Ce qui entraînera la désactivation du clavier.

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