Détecter si une touche est enfoncée en C # (pas A, B, mais tout)
[EDIT 3]
J'ai une sorte de "résolu" par à l'aide de la "étrange" de la version. Au moins pour les touches les plus importantes. Il est suffisants pour permettre mon cas, où je veux vérifier que la touche ALT et ALT+ne sont pas les mêmes (assurant ainsi Un n'est pas pressé). Pas parfait, mais déjà beaucoup de temps pour un petit problème. Merci à tous pour les réponses en tout cas...
[EDIT 3]
[EDIT 4] Résolu beaucoup plus propre grâce à 280Z28 [/EDIT 4]
Je sais comment faire pour vérifier les touches de modification et la façon de tester pour une touche unique.
Le problème est, je veux vérifier si une touche est enfoncée. L'approche suivante semble "étrange" 🙂
WPF Application écrite en C#
if (Keyboard.IsKeyDown(Key.A)) return true;
if (Keyboard.IsKeyDown(Key.B)) return true;
if (Keyboard.IsKeyDown(Key.C)) return true;
Je sais que c'est un enum, alors j'ai pensé à une boucle, mais qu'est-ce que le "plus grand nombre" à utiliser. Et est-ce possible? btw, c'est un cas très spécial, normalement, je voudrais utiliser un événement, mais dans ce cas je dois le faire de cette façon. Unfortunatily, il n'existe pas de "liste" du Clavier.CurrentlyDownKeys. Au moins je n'ai pas la voir.
Grâce,
Chris
EDIT: Ok, parce qu'il semble être un gros deal, voici la raison pour cela:
J'ai défini un "Clavier", qui sert de DictionaryKey pour des fonctions personnalisées. Si quelqu'un clique sur un élément, le wrapper parcourt le dictionnaire et vérifie si les prédéfinis "Claviers" est active.
Cela me permet de définir simple déclencheurs, comme par exemple Exécuter cette fonction si les touches ALT+A+B est maintenu enfoncé. Une autre option est par exemple Exécuter cette fonction si les touches ALT+CTRL+A est enfoncé (lors d'un clic de souris sur un WPF élément).
Le seul "problème" avec l'implémentation actuelle, si je définis un jeu de clés qui ne contiennent PAS de vraies touches, comme s'exécuter si la touche ALT est enfoncée, il est également déclenchée si les touches ALT+A est enfoncé. Oh, tout en écrivant cela, je me rends compte qu'il y a un autre problème. ALT+A+B serait actuellement également déclencher si les touches ALT+A+B+C est pressé.
Peut-être que mon approche est erronée, et je doit créer une "clé statique tracker" et de comparer le jeu de clés à ses valeurs (acquis par l'entremise d'événements).. je vais donner à ceci un essai.
EDIT 2
Cela ne fonctionne pas, du moins pas de façon simple. J'ai besoin d'un FrameworkElement à joindre à KeyDown, mais je ne l'ai pas dans un constructeur statique. Et je ne suis pas intéressé par KeyDownEvents d'un certain élément, mais "globalement"...je crois que j'avance reporter ce problème, n'est pas si important. Encore, si quelqu'un connait une meilleure approche différente...
Si longtemps, pour quelqu'un qui se soucie, voici un peu de code:
public class KeyModifierSet
{
internal readonly HashSet<Key> Keys = new HashSet<Key>();
internal readonly HashSet<ModifierKeys> MKeys = new HashSet<ModifierKeys>();
public override int GetHashCode()
{
int hash = Keys.Count + MKeys.Count;
foreach (var t in Keys)
{
hash *= 17;
hash = hash + t.GetHashCode();
}
foreach (var t in MKeys)
{
hash *= 19;
hash = hash + t.GetHashCode();
}
return hash;
}
public override bool Equals(object obj)
{
return Equals(obj as KeyModifierSet);
}
public bool Equals(KeyModifierSet other)
{
//Check for null
if (ReferenceEquals(other, null))
return false;
//Check for same reference
if (ReferenceEquals(this, other))
return true;
//Check for same Id and same Values
return Keys.SetEquals(other.Keys) && MKeys.SetEquals(other.MKeys);
}
public bool IsActive()
{
foreach (var k in Keys)
if (Keyboard.IsKeyUp(k)) return false;
if ((Keys.Count == 0) && !Keyboard.IsKeyDown(Key.None)) return false;
foreach (var k in MKeys)
if ((Keyboard.Modifiers & k) == 0) return false;
if ((MKeys.Count == 0) && Keyboard.Modifiers > 0) return false;
return true;
}
public KeyModifierSet(ModifierKeys mKey)
{
MKeys.Add(mKey);
}
public KeyModifierSet()
{
}
public KeyModifierSet(Key key)
{
Keys.Add(key);
}
public KeyModifierSet(Key key, ModifierKeys mKey)
{
Keys.Add(key);
MKeys.Add(mKey);
}
public KeyModifierSet Add(Key key)
{
Keys.Add(key);
return this;
}
public KeyModifierSet Add(ModifierKeys key)
{
MKeys.Add(key);
return this;
}
}
source d'informationauteur Christian Ruppert
Vous devez vous connecter pour publier un commentaire.
En utilisant le XNA framework, vous pouvez utiliser le thw suivre pour vérifier si une touche a été pressée.
Tout à fait une vieille question, mais au cas où quelqu'un vient à travers cela et ne veut pas l'utiliser dll externe, vous pouvez simplement énumérer les clés possibles et boucle sur eux.
Vous pouvez optimiser un peu tout ça en faisant l'énumération à l'extérieur de la fonction et le maintien de la liste pour plus tard.
Où est-ce que le code qui s'exécute? Est-il dans un gestionnaire d'événement? De nombreux formulaires et contrôles de déclencher un événement KeyPress ainsi que d'un événement KeyDown. Vous voudrez peut-être chercher dans ces événements et de définir votre drapeau à true lorsque l'un d'entre eux se produit. Vous pouvez également l'écouter pour l'événement correspondant qui vous indique lorsque la touche est relâchée (KeyUp, aussi, je pense).
Si vous utilisez
Windows.Forms
utilisez leKeyDown
de l'événement et de la lecture de la clé spécifique à l'aide de laKeyEventArgs
. Vous pouvez accéder à laKeyCode
bien sur laKeyEventArgs
variable.Pour vérifier les plages, disons entre A et Z:
http://sourceforge.net/projects/keystate/ montre "spécial" du clavier. Sinon je pense que tu vas juste avoir à les surveiller. Sonne comme vous voulez le faire à l'échelle du système? Qu'essayez-vous de réaliser?
Vous pouvez incrémenter un compteur pour chaque événement keydown, et de décrémentation pour chaque événement keyup. Lorsque le compteur est à zéro, pas de clés sont à la baisse.
Vous devez toujours utiliser un événement, de préférence KeyDown puisque vous n'avez pas l'esprit de ce que touche est enfoncée, si vous êtes à la programmation sous windows. Si non, vous pouvez utiliser quelque chose comme de la Console.ReadLine();.
edit: Si vous cherchez quelque chose comme
alors vous devez être à plaisanter...
edit 2: Bien, l'approche de votre enregistreur est intéressant, mais je pense que vous êtes en train de réinventer la roue. Tous les langages de programmation fournit une certaine façon de gérer qui touche a été pressée, lors de ce qui peut être connu. En C# pour Windows, ceci est fait en utilisant des événements. D'ailleurs, je pense que vous ne serez pas en mesure de gérer ce genre de choses par vous-même .NET, puisque vous avez besoin d'accéder à certaines fonctions du système à partir de l'API Win32, et autant que je sache, vous n'êtes pas autorisé à le faire (au moins...) en code managé. Une solution serait de créer un CROCHET et d'envoyer des messages à partir de là, à votre demande, mais je ne sais pas comment le faire en C#. C'était la voie à Delphes, où j'ai plus d'expérience.