Je travaille actuellement sur une application qui nécessite un comportement différent selon lequel l'utilisateur appuie sur la touche Maj Droite ou à gauche (Rshifty, Lshifty), cependant, lorsque l'une de ces clés est enfoncée, je ne vois que Squikey | Décalage.
Y a-t-il quelque chose qui ne va pas avec mon clavier? (ordinateur portable) Dois-je besoin d'un nouveau pilote / clavier de clavier afin d'envoyer les différentes commandes de clé peut-être ...
C'est un problème assez massif pour le moment, car il n'ya aucun moyen de tester que le code fonctionne (à part des tests unitaires). Toute personne a eu une expérience des différentes touches Maj / Alt / Ctrl?
4 Réponses :
Je ne sais pas si ce message vous aidera ou non, mais on dirait que vous devrez peut-être gâcher avec les intersopservices et les diagnostics:
Forum MSDN: Comment envoyer la touche Maj Droite P>
Edit: Strong> J'ai finalement compris comment faire des travaux de getasynckeystate (), car Adrianbanks a révélé. P>
[System.Runtime.InteropServices.DllImport("user32.dll")]
private static extern short GetAsyncKeyState(Keys vKey);
private void theForm_KeyDown(object sender, KeyEventArgs e)
{
if (e.KeyCode == Keys.ShiftKey)
{
if (Convert.ToBoolean(GetAsyncKeyState(Keys.LShiftKey)))
{
Console.WriteLine("Left");
}
if (Convert.ToBoolean(GetAsyncKeyState(Keys.RShiftKey)))
{
Console.WriteLine("Right");
}
}
}
Bonjour - Oui, je regarde ce post avant, mais il ne parle que d'envoyer le coup clé. Ce qui est étrange, c'est que le clavier lui-même n'envoie tout simplement jamais ces "clés". Je suppose donc que j'ai besoin de modifier quelque chose sous Windows pour permettre à mon clavier de l'appuyer, ou d'obtenir un nouveau pilote, ou les deux.
Jetez un coup d'œil au GetASynCeyState Méthode Win32. Vous pouvez ajouter un appel de Pinvoke à l'aide de: puis gérez l'événement sur votre formulaire:
Merci gars, bonne solution là-bas. En attendant, voici mon propre moyen de le faire de la substitution de processcmdkey:
C'est une solution bien meilleure que celle marquée comme réponse; getasynckeystate ne peut pas être invoqué pour donner des résultats corrects (il peut signaler que la clé n'est pas poussée, malgré votre application recevant un événement qu'il est), tandis que votre solution peut être invoquée (bien que ces codes spécifiques peut varier à travers différents OSS).
M. AH: Jetez un coup d'œil à la solution du Dr d'Nar. Il est beaucoup plus compréhensible.
J'avais un besoin similaire de différencier les touches de déplacement et de commande de gauche et de droite. Voici ma solution plutôt plus longue mais peut-être meilleure. Si vous souhaitez attraper les touches Alt, vous devrez remplacer d'autres choses pour les empêcher d'activer tout menu (s). ((int) m.lparam & 0xFFFFF) code> devrait donner le nombre de répétitions, mais il ne semble jamais aller au-dessus de 2. protected override bool ProcessKeyMessage(ref Message m)
{
if ((m.Msg == WM_KEYDOWN || m.Msg == WM_KEYUP) && ((int)m.WParam == VK_CONTROL || (int)m.WParam == VK_SHIFT))
{
KeyEventArgs e = new KeyEventArgs(Keys.None);
switch ((OemScanCode)(((int)m.LParam >> 16) & 0x1FF))
{
case OemScanCode.LControl:
e = new KeyEventArgs(Keys.LControlKey);
break;
case OemScanCode.RControl:
e = new KeyEventArgs(Keys.RControlKey);
break;
case OemScanCode.LShift:
e = new KeyEventArgs(Keys.LShiftKey);
break;
case OemScanCode.RShift:
e = new KeyEventArgs(Keys.RShiftKey);
break;
default:
if ((int)m.WParam == VK_SHIFT)
e = new KeyEventArgs(Keys.ShiftKey);
else if ((int)m.WParam == VK_CONTROL)
e = new KeyEventArgs(Keys.ControlKey);
break;
}
if (e.KeyData != Keys.None)
{
if (m.Msg == WM_KEYDOWN)
OnKeyDown(e);
else
OnKeyUp(e);
return true;
}
}
return base.ProcessKeyMessage(ref m);
}
#region Scan code & window message stuff
const int WM_KEYDOWN = 0x100;
const int WM_KEYUP = 0x101;
const int VK_SHIFT = 0x10;
const int VK_CONTROL = 0x11;
/// <summary>
/// Alt key
/// </summary>
const int VK_MENU = 0x12;
/// <summary>
/// List of scan codes for standard 104-key keyboard US English keyboard
/// </summary>
enum OemScanCode
{
/// <summary>
/// ` ~
/// </summary>
BacktickTilde = 0x29,
/// <summary>
/// 1 !
/// </summary>
N1 = 2,
/// <summary>
/// 2 @
/// </summary>
N2 = 3,
/// <summary>
/// 3 #
/// </summary>
N3 = 4,
/// <summary>
/// 4 $
/// </summary>
N4 = 5,
/// <summary>
/// 5 %
/// </summary>
N5 = 6,
/// <summary>
/// 6 ^
/// </summary>
N6 = 7,
/// <summary>
/// 7 &
/// </summary>
N7 = 8,
/// <summary>
/// 8 *
/// </summary>
N8 = 9,
/// <summary>
/// 9 (
/// </summary>
N9 = 0x0A,
/// <summary>
/// 0 )
/// </summary>
N0 = 0x0B,
/// <summary>
/// - _
/// </summary>
MinusDash = 0x0C,
/// <summary>
/// = +
/// </summary>
Equals = 0x0D,
Backspace = 0x0E,
Tab = 0x0F,
Q = 0x10,
W = 0x11,
E = 0x12,
R = 0x13,
T = 0x14,
Y = 0x15,
U = 0x16,
I = 0x17,
O = 0x18,
P = 0x19,
/// <summary>
/// [ {
/// </summary>
LBracket = 0x1A,
/// <summary>
/// ] }
/// </summary>
RBracket = 0x1B,
/// <summary>
/// | \ (same as pipe)
/// </summary>
VerticalBar = 0x2B,
/// <summary>
/// | \ (same as vertical bar)
/// </summary>
Pipe = 0x2B,
CapsLock = 0x3A,
A = 0x1E,
S = 0x1F,
D = 0x20,
F = 0x21,
G = 0x22,
H = 0x23,
J = 0x24,
K = 0x25,
L = 0x26,
/// <summary>
/// ; :
/// </summary>
SemiColon = 0x27,
/// <summary>
/// ' "
/// </summary>
Quotes = 0x28,
// Unused
Enter = 0x1C,
LShift = 0x2A,
Z = 0x2C,
X = 0x2D,
C = 0x2E,
V = 0x2F,
B = 0x30,
N = 0x31,
M = 0x32,
/// <summary>
/// , <
/// </summary>
Comma = 0x33,
/// <summary>
/// . >
/// </summary>
Period = 0x34,
/// <summary>
/// / ?
/// </summary>
Slash = 0x35,
RShift = 0x36,
LControl = 0x1D,
LAlternate = 0x38,
SpaceBar = 0x39,
RAlternate = 0x138,
RControl = 0x11D,
/// <summary>
/// The menu key thingy
/// </summary>
Application = 0x15D,
Insert = 0x152,
Delete = 0x153,
Home = 0x147,
End = 0x14F,
PageUp = 0x149,
PageDown = 0x151,
UpArrow = 0x148,
DownArrow = 0x150,
LeftArrow = 0x14B,
RightArrow = 0x14D,
NumLock = 0x145,
NumPad0 = 0x52,
NumPad1 = 0x4F,
NumPad2 = 0x50,
NumPad3 = 0x51,
NumPad4 = 0x4B,
NumPad5 = 0x4C,
NumPad6 = 0x4D,
NumPad7 = 0x47,
NumPad8 = 0x48,
NumPad9 = 0x49,
NumPadDecimal = 0x53,
NumPadEnter = 0x11C,
NumPadPlus = 0x4E,
NumPadMinus = 0x4A,
NumPadAsterisk = 0x37,
NumPadSlash = 0x135,
Escape = 1,
PrintScreen = 0x137,
ScrollLock = 0x46,
PauseBreak = 0x45,
LeftWindows = 0x15B,
RightWindows = 0x15C,
F1 = 0x3B,
F2 = 0x3C,
F3 = 0x3D,
F4 = 0x3E,
F5 = 0x3F,
F6 = 0x40,
F7 = 0x41,
F8 = 0x42,
F9 = 0x43,
F10 = 0x44,
F11 = 0x57,
F12 = 0x58,
}
#endregion
Merci d'Nar! Cette solution semble être meilleure pour moi, puis les autres. Principalement parce qu'il n'y a pas d'autres appels, cela fonctionne simplement avec les données d'origine. Donc, c'est plus long, mais en fait plus rapide et plus stable.
Je vois .net, mais quelle est votre plate-forme? WPF? Winforms? Console? Silverlight?
Désolé bon point - c'est simplement Winforms. Bien que je suppose qu'un accident clé est un coup clé, ou est que seulement la pointe de ma naïveté sur ce sujet.
Apparemment distinguant entre gauche et droite la place dans la catégorie de "clé virtuelle" qui nécessite un peu d'effort supplémentaire pour travailler.