Aufwärts-, Abwärts-, Links- und Rechtspfeiltasten lösen kein KeyDown-Ereignis aus

Ich erstelle eine Anwendung, in der alle Schlüsseleingaben von den Fenstern selbst verarbeitet werden müssen.

Ich habe Tabstop für jedes Steuerelement auf false gesetzt, das den Fokus außer einem Bedienfeld erfassen kann (aber ich weiß nicht, ob es Auswirkungen hat).

Ich habe KeyPreview auf true gesetzt und behandle das KeyDown-Ereignis in diesem Formular.

Mein Problem ist, dass die Pfeiltaste manchmal nicht mehr reagiert:

• Das Keydown-Ereignis wird nicht ausgelöst, wenn ich nur eine Pfeiltaste gedrückt habe.

• Das Keydown-Ereignis wird ausgelöst, wenn ich mit dem Steuermodifikator eine Pfeiltaste drücke.

Haben Sie eine Idee, warum meine Pfeiltaste plötzlich aufhört, ein Ereignis auszulösen?

    protected override bool IsInputKey(Keys keyData)
    {
        switch (keyData)
        {
            case Keys.Right:
            case Keys.Left:
            case Keys.Up:
            case Keys.Down:
                return true;
            case Keys.Shift | Keys.Right:
            case Keys.Shift | Keys.Left:
            case Keys.Shift | Keys.Up:
            case Keys.Shift | Keys.Down:
                return true;
        }
        return base.IsInputKey(keyData);
    }
    protected override void OnKeyDown(KeyEventArgs e)
    {
        base.OnKeyDown(e);
        switch (e.KeyCode)
        {
            case Keys.Left:
            case Keys.Right:
            case Keys.Up:
            case Keys.Down:
                if (e.Shift)
                {

                }
                else
                {
                }
                break;                
        }
    }

Ich hatte genau das gleiche Problem. Ich dachte über die Antwort nach, die @Snarfblam gegeben hatte. Wenn Sie jedoch die Dokumentation zu MSDN lesen, soll die ProcessCMDKey-Methode wichtige Ereignisse für Menüelemente in einer Anwendung überschreiben.

Ich bin kürzlich auf diesen Artikel von Microsoft gestoßen, der ziemlich vielversprechend aussieht: http://msdn.microsoft.com/en-us/library/system.windows.forms.control.previewkeydown.aspx . Laut Microsoft ist es am besten, e.IsInputKey=true;das PreviewKeyDownEreignis nach dem Erkennen der Pfeiltasten einzustellen . Andernfalls wird das KeyDownEreignis ausgelöst.

Dies hat für mich ganz gut funktioniert und war weniger hackig als das Überschreiben des ProcessCMDKey.

Ich benutze PreviewKeyDown

    private void _calendar_PreviewKeyDown(object sender, PreviewKeyDownEventArgs e){
        switch (e.KeyCode){
            case Keys.Down:
            case Keys.Right:
                //action
                break;
            case Keys.Up:
            case Keys.Left:
                //action
                break;
        }
    }

Siehe Rodolfo Neuber Antwort für die beste Antwort

(Meine ursprüngliche Antwort):

Leiten Sie von einer Steuerungsklasse ab und Sie können die ProcessCmdKey-Methode überschreiben. Microsoft hat diese Schlüssel in KeyDown-Ereignissen weggelassen, da sie sich auf mehrere Steuerelemente auswirken und den Fokus verschieben. Dies macht es jedoch sehr schwierig, eine App auf andere Weise auf diese Schlüssel reagieren zu lassen.

Leider ist es aufgrund von Einschränkungen bei KeyDown-Ereignissen ziemlich schwierig, dies mit den Pfeiltasten zu erreichen. Es gibt jedoch einige Möglichkeiten, dies zu umgehen:

• Wie in @Snarfblam angegeben, können Sie die ProcessCmdKey-Methode überschreiben , mit der die Pfeiltasten nicht mehr analysiert werden können.
• Wie in der akzeptierten Antwort auf diese Frage angegeben , verfügt XNA über eine integrierte Methode namens Keyboard.GetState () , mit der Sie Pfeiltasteneingaben verwenden können. Allerdings hat WinForms nicht, aber es kann durch eine P / Invoke erfolgen , oder durch eine Klasse verwenden , die mit ihm hilft .

Ich empfehle, diese Klasse zu verwenden. Das geht ganz einfach:

var left = KeyboardInfo.GetKeyState(Keys.Left);
var right = KeyboardInfo.GetKeyState(Keys.Right);
var up = KeyboardInfo.GetKeyState(Keys.Up);
var down = KeyboardInfo.GetKeyState(Keys.Down);

if (left.IsPressed)
{
//do something...
}

//etc...

Wenn Sie dies in Kombination mit dem KeyDown-Ereignis verwenden, können Sie Ihr Ziel meiner Meinung nach zuverlässig erreichen.

Ich hatte ein ähnliches Problem beim Aufrufen des WPF-Fensters aus WinForms.

var wpfwindow = new ScreenBoardWPF.IzbiraProjekti();
    ElementHost.EnableModelessKeyboardInterop(wpfwindow);
    wpfwindow.Show();

Das Anzeigen des Fensters als Dialogfeld funktionierte jedoch

var wpfwindow = new ScreenBoardWPF.IzbiraProjekti();
    ElementHost.EnableModelessKeyboardInterop(wpfwindow);
    wpfwindow.ShowDialog();

Hoffe das hilft.

Um Tastenanschläge in einem Forms-Steuerelement zu erfassen, müssen Sie eine neue Klasse ableiten, die auf der Klasse des gewünschten Steuerelements basiert, und Sie überschreiben den ProcessCmdKey ().

protected override bool ProcessCmdKey(ref Message msg, Keys keyData)
{
    //handle your keys here
}

Beispiel:

protected override bool ProcessCmdKey(ref Message msg, Keys keyData)
{
    //capture up arrow key
    if (keyData == Keys.Up )
    {
        MessageBox.Show("You pressed Up arrow key");
        return true;
    }

    return base.ProcessCmdKey(ref msg, keyData);
}

Vollständige Quelle ... Pfeiltasten in C #

Vayne

Ich denke, der beste Weg, dies zu tun, besteht darin, damit umzugehen, wie der MSDN auf http://msdn.microsoft.com/en-us/library/system.windows.forms.control.previewkeydown.aspx sagte

Aber geh damit um, wie du es wirklich brauchst. Mein Weg (im folgenden Beispiel) ist es, jeden KeyDown zu fangen ;-)

    /// <summary>
    /// onPreviewKeyDown
    /// </summary>
    /// <param name="e"></param>
    protected override void OnPreviewKeyDown(PreviewKeyDownEventArgs e)
    {
        e.IsInputKey = true;
    }

    /// <summary>
    /// onKeyDown
    /// </summary>
    /// <param name="e"></param>
    protected override void OnKeyDown(KeyEventArgs e)
    {
        Input.SetFlag(e.KeyCode);
        e.Handled = true;
    }

    /// <summary>
    /// onKeyUp
    /// </summary>
    /// <param name="e"></param>
    protected override void OnKeyUp(KeyEventArgs e)
    {
        Input.RemoveFlag(e.KeyCode);
        e.Handled = true;
    }

Ich hatte das gleiche Problem und verwendete bereits den Code in der ausgewählten Antwort. Dieser Link war die Antwort für mich; vielleicht auch für andere.

Wie deaktiviere ich die Navigation in WinForm mit Pfeilen in C #?

protected override bool IsInputKey(Keys keyData)
{
    if (((keyData & Keys.Up) == Keys.Up)
        || ((keyData & Keys.Down) == Keys.Down)
        || ((keyData & Keys.Left) == Keys.Left)
        || ((keyData & Keys.Right) == Keys.Right))
        return true;
    else
        return base.IsInputKey(keyData);
}