La détection ctrl+v sur la touche

Je suis en utilisant la zone de texte keypress événement à ne traiter que les entrées sélectionnées. Fondamentalement, la textbox permettre à l'utilisateur d'entrer des valeurs où il peut être calculé.

c'est à dire que vous pouvez taper (5*5)- (10/5).

La méthode actuelle vérifier comme Convert.ToChar("*")==e.KeyChar etc...

À l'instant, il ne veut pas permettre à l'utilisateur de copier coller des valeurs.

Est-il de toute façon qui peut détecter la ctrl+v sur keypress événement?

Mise à jour

Ce que je fais en ce moment

   static IEnumerable<char> ValidFiancialCharacters
       {
           get
           {
               if(_validFiancialCharacters==null)
               {
                 _validFiancialCharacters = new List<char>();

                 _validFiancialCharacters.Add(Convert.ToChar("0"));
                 _validFiancialCharacters.Add(Convert.ToChar("1"));
                 _validFiancialCharacters.Add(Convert.ToChar("2"));
                 //till 9 and
                  _validFiancialCharacters.Add(Convert.ToChar("+"));
                  _validFiancialCharacters.Add(Convert.ToChar("-"));
                  _validFiancialCharacters.Add(Convert.ToChar("/"));
                  //and some other
                }
                return _validFiancialCharacters;
             }
       }


 public static bool ValidateInput(KeyPressEventArgs e)
   {
       if (ValidFiancialCharacters.Any(chr => chr == e.KeyChar))
       {
           e.Handled = false;
       }
       else
       {
           e.Handled = true;
       }
       return e.Handled;
   }

Et dans le keypress

   private void txtRate_KeyPress(object sender, KeyPressEventArgs e)
    {
        NumberExtension.ValidateInput(e);
    }

Pourquoi travaillez-vous au niveau des touches? Ne pouvez-vous pas simplement évaluer textbox.Text sur le changement, en laissant la responsabilité pour les clés et les copier / coller avec la zone de texte standard qui gère tout ça?
Je suis restreindre l'utilisateur à l'entrée de certaines valeurs. Autoriser uniquement certaines valeurs

OriginalL'auteur | 2014-08-05

.net c#keypress

4

Si vous avez besoin de gérer à la fois, peut être fait en utilisant la même approche

Ont un coup d'oeil à Codes De Clé. Vous pouvez détecter ce que jamais la touche pressée

donc..

Créer une liste contenant toutes les entrées que vous devez
```
 public List<int> KeyCodes = new List<int>() { 8, 17, 37, 39.....etc}; 
```
et l'utilisation de la KeyDown événement et l'utilisation KeyEventArgs.SuppressKeyPress propriété
```
private void Txt1_KeyDown(object sender, KeyEventArgs e)
{
    if (KeyCodes.Contains(e.KeyValue) || (e.KeyCode==Keys.V && e.Control))
        e.SuppressKeyPress = false;
    else 
        e.SuppressKeyPress=true;
}
```
Vous pourriez avoir besoin pour valider la copie collé de la valeur dans leave event, puisque l'utilisateur peut coller n'importe quoi!!!

Super, exactement ce que je voulais
Il y a un problème avec KeyDown et SuppressKeyPress que si vous voulez autoriser uniquement certaines touches, il supprime toutes les autres touches sur le niveau de forme. par exemple, Alt+F4

OriginalL'auteur huMpty duMpty

Il suffit de regarder les Modificateurs de biens en vous KeyDown ou KeyUp événement pour Keys.Control

Modificateurs Obtient le modificateur de drapeaux pour un KeyDown ou événement KeyUp. Les drapeaux indiquent la combinaison de touches CTRL, SHIFT et les touches ALT est enfoncée.

Échantillon

KeyDown

 this.myTextBox.KeyDown += new KeyEventHandler(myTextBox_KeyDown);

 private void myTextBox_KeyDown(object sender, KeyEventArgs e)
 {
      if (e.KeyCode == Keys.V && e.Modifiers == Keys.Control)
      {
            MessageBox.Show("Hello world");
      }
  }

ou KeyUp

 this.myTextBox.KeyUp += new KeyEventHandler(myTextBox_KeyUp);

 private void myTextBox_KeyUp(object sender, KeyEventArgs e)
 {
      if (e.KeyCode == Keys.V && e.Modifiers == Keys.Control)
      {
            MessageBox.Show("Hello world");
      }
  }

Mise à jour

Pour autoriser uniquement certaines entrées, vous pouvez utiliser le KeyPress événement.

this.myTextBox.KeyPress += new KeyPressEventHandler(this.myTextBox_KeyPress);

private void myTextBox_KeyPress(object sender, KeyPressEventArgs e)
{
    int i;
    if (int.TryParse(e.KeyChar.ToString(), out i) || 
        e.KeyChar == '(' ||
        e.KeyChar == ')' ||
        e.KeyChar == '.' ||
        e.KeyChar == '*' ||
        e.KeyChar == '+' ||
        e.KeyChar == '-' ||
        e.KeyChar == '/'
        //add some more)
    {

    } else e.Handled = true; //dont allow other inputs
}

Plus D'Informations

Salut, merci. Mais vais-je être en mesure d'effectuer les autres comme je l'ai mentionné dans la question. pour permettre à certains caractères seulement. À l'aide de la keyup?
Avez-vous essayé ?
J'ai à la fois les événements du moment. Donc, l'événement passer de KeyDown il échoue à partir de keypress
Pression de touche ne fonctionne pas pour la Touche CTRL enfoncée, utilisez KeyDown ou KeyUp.
Oui, je sais, mais le problème que j'ai est d'autoriser que certains autres personnages avec ctrl+v. c'est à dire tous les nombres, et une autre entrée comme +,-,* etc...

OriginalL'auteur dknaack

2

KeyPress événement n'a pas l'attraper "Ctrl + V" pour une raison quelconque. Utilisation KeyDown événement:
```
private void textBox1_KeyDown(object sender, KeyEventArgs e)
{
    if (e.Control && e.KeyCode == Keys.V)
    {
        //Ctrl + V
    }
}
```
ou
```
private void textBox1_KeyDown(object sender, KeyEventArgs e)
{
    if (e.KeyData == (Keys.Control | Keys.V))
    {
        //Ctrl + V
    }
}
```
Salut, j'ai besoin pour n'autoriser que certains autres caractères avec les touches ctrl+v. c'est à dire tous les nombres, et une autre entrée comme +,-,* . Est-il possible de l'événement keydown?
Non, vous ne pouvez pas. Vous avez besoin d'hériter de votre zone de texte, remplacer WndProc et poignée Wm_Paste message. Sinon, vous pouvez utiliser TextChanged événement pour voir ce que l'utilisateur les a collé/
Non, je m'occupe de l'collé valeur séparément. Mais pour permettre à type de valeurs, comme je l'ai mentionné plus tôt
C'est ce que j'ai dit, vous avez besoin pour gérer Wm_Paste et de vérifier que l'utilisateur est le collage, vous pouvez décider de permettre ou pas.

OriginalL'auteur Sriram Sakthivel

Le Ctrl+V séquence peut être exercé par événement keypressevent.

Vous juste ne peut pas vérifier de la manière suivante :

(Keys)e.KeyChar == Keys.V && Control.ModifierKeys == Keys.Control <br>

Vous devez utiliser:

(int)e.KeyChar==22 && Control.ModifierKeys == Keys.Control <br>

parce que le keybord génère de l'ASCII=22 (synchrone en veille).

L'exemple suivant active la zone de texte à accepter +- montants avec virgule de séparation et permet à coller par Ctrl+V

protected override void OnKeyPress(KeyPressEventArgs e)
{
    if (!( char.IsNumber(e.KeyChar) ||
         ((Keys)e.KeyChar == Keys.Back) ||
         (e.KeyChar == ',') ||
         (e.KeyChar == '-') ||
         ((int)e.KeyChar==22 && Control.ModifierKeys == Keys.Control)
        ))
        {
            e.Handled = true;
        }
        if (e.KeyChar == ',' && base.Text.IndexOf(',') > 0)
        {
            e.Handled = true;
        }
        base.OnKeyPress(e);
    }

OriginalL'auteur Sylwester Santorowski

0

Vous devez utiliser KeyDown ou KeyUp, parce que la pression de Touche de l'événement n'est pas déclenché par le bouton CTRL, mais seulement par "caractère" des boutons. Si vous utilisez l'événement KeyDown vous pouvez détecter ctrl+v en cochant:
```
if (e.Control && e.KeyCode == Keys.V)
{
    ...
}
```
OriginalL'auteur Brutus

Vous devez vous connecter pour publier un commentaire.