Porady: modyfikowanie sygnału z klawiatury do kontrolki standardowej

Artykuł
10/19/2023

Formularze systemu Windows umożliwiają używanie i modyfikowanie danych wejściowych klawiatury. Użycie klucza odnosi się do obsługi klucza w metodzie lub procedurze obsługi zdarzeń, tak aby inne metody i zdarzenia dalej w kolejce komunikatów nie odbierały wartości klucza. Modyfikowanie klucza odnosi się do modyfikowania wartości klucza, dzięki czemu metody i procedury obsługi zdarzeń w dalszej części kolejki komunikatów otrzymują inną wartość klucza. W tym temacie przedstawiono sposób wykonywania tych zadań.

Aby użyć klucza

W procedurze obsługi zdarzeń KeyPress ustaw Handled właściwość KeyPressEventArgs klasy na true.

— lub —

W procedurze obsługi zdarzeń KeyDown ustaw Handled właściwość KeyEventArgs klasy na true.

Uwaga

Handled Ustawienie właściwości w procedurze KeyDown obsługi zdarzeń nie uniemożliwia KeyPress wywoływanie zdarzeń i KeyUp dla bieżącego naciśnięcia klawiszy. SuppressKeyPress Użyj właściwości w tym celu.

Poniższy przykład to fragment switch instrukcji, która analizuje KeyChar właściwość KeyPressEventArgs odebranego przez procedurę obsługi zdarzeń KeyPress . Ten kod używa kluczy znaków "A" i "a".
```
// Consume 'A' and 'a'.
case (char)65:
case (char)97:
    MessageBox.Show("Control.KeyPress: '" +
        e.KeyChar.ToString() + "' consumed.");
    e.Handled = true;
    break;
```
```
' Consume 'A' and 'a'.
Case ChrW(65), ChrW(97)
    MessageBox.Show(("Control.KeyPress: '" + _
        e.KeyChar.ToString() + "' consumed."))
    e.Handled = True
```

Aby zmodyfikować standardowy klucz znaku

W procedurze obsługi zdarzeń KeyPress ustaw KeyChar właściwość KeyPressEventArgs klasy na wartość nowego klucza znaku.

Poniższy przykład to fragment switch instrukcji, która modyfikuje ciąg "B" na "A" i "b" na "a". Należy pamiętać, że Handled właściwość parametru KeyPressEventArgs jest ustawiona na false, aby nowa wartość klucza została propagowana do innych metod i zdarzeń w kolejce komunikatów.

// Detect 'B', modify it to 'A', and forward the key.
case (char)66:
    MessageBox.Show("Control.KeyPress: '" +
        e.KeyChar.ToString() + "' replaced by 'A'.");
    e.KeyChar = (char)65;
    e.Handled = false;
    break;

// Detect 'b', modify it to 'a', and forward the key.
case (char)98:
    MessageBox.Show("Control.KeyPress: '" +
        e.KeyChar.ToString() + "' replaced by 'a'.");
    e.KeyChar = (char)97;
    e.Handled = false;
    break;

    ' Modify 'B' to 'A' and forward the key.
Case ChrW(66)
    MessageBox.Show(("Control.KeyPress: '" + _
        e.KeyChar.ToString() + "' replaced by 'A'."))
    e.KeyChar = ChrW(65)
    e.Handled = False

    ' Modify 'b' to 'a' and forward the key.
Case ChrW(98)
    MessageBox.Show(("Control.KeyPress: '" + _
        e.KeyChar.ToString() + "' replaced by 'a'."))
    e.KeyChar = ChrW(97)
    e.Handled = False

Aby zmodyfikować klucz nietypowy

Zastąpij metodę przetwarzającą Control komunikaty systemu Windows, wykrywającą komunikat WM_KEYDOWN lub WM_SYSKEYDOWN i ustawiającą WParam właściwość Message parametru na Keys wartość reprezentującą nowy klucz nietypowy.

W poniższym przykładzie kodu pokazano, jak przesłonić PreProcessMessage metodę kontrolki w celu wykrywania klawiszy F1 do F9 i modyfikowania dowolnego klawisza F3 na klawisz F1. Aby uzyskać więcej informacji na Control temat metod, które można przesłonić w celu przechwytywania komunikatów klawiaturowych, zobacz Dane wejściowe użytkownika w aplikacji Formularzy systemu Windows i Jak działa wprowadzanie klawiatury.

// Detect F1 through F9 during preprocessing and modify F3.
public override bool PreProcessMessage(ref Message m)
{
    if (m.Msg == WM_KEYDOWN)
    {
        Keys keyCode = (Keys)m.WParam & Keys.KeyCode;

        // Detect F1 through F9.
        switch (keyCode)
        {
            case Keys.F1:
            case Keys.F2:
            case Keys.F3:
            case Keys.F4:
            case Keys.F5:
            case Keys.F6:
            case Keys.F7:
            case Keys.F8:
            case Keys.F9:

                MessageBox.Show("Control.PreProcessMessage: '" +
                  keyCode.ToString() + "' pressed.");

                // Replace F3 with F1, so that ProcessKeyMessage will
                // receive F1 instead of F3.
                if (keyCode == Keys.F3)
                {
                    m.WParam = (IntPtr)Keys.F1;
                    MessageBox.Show("Control.PreProcessMessage: '" +
                        keyCode.ToString() + "' replaced by F1.");
                }
                break;
        }
    }

    // Send all other messages to the base method.
    return base.PreProcessMessage(ref m);
}

' Detect F1 through F9 during preprocessing and modify F3.
Public Overrides Function PreProcessMessage(ByRef m As Message) _
    As Boolean

    If m.Msg = WM_KEYDOWN Then
        Dim keyCode As Keys = CType(m.WParam, Keys) And Keys.KeyCode

        ' Detect F1 through F9.
        Select Case keyCode
            Case Keys.F1, Keys.F2, Keys.F3, Keys.F4, Keys.F5, _
                 Keys.F6, Keys.F7, Keys.F8, Keys.F9

                MessageBox.Show(("Control.PreProcessMessage: '" + _
                    keyCode.ToString() + "' pressed."))

                ' Replace F3 with F1, so that ProcessKeyMessage will  
                ' receive F1 instead of F3.
                If keyCode = Keys.F3 Then
                    m.WParam = CType(Keys.F1, IntPtr)
                    MessageBox.Show(("Control.PreProcessMessage: '" + _
                        keyCode.ToString() + "' replaced by F1."))
                End If
        End Select
    End If

    ' Send all other messages to the base method.
    Return MyBase.PreProcessMessage(m)
End Function

Przykład

Poniższy przykład kodu to kompletna aplikacja przykładów kodu w poprzednich sekcjach. Aplikacja używa niestandardowej kontrolki pochodzącej TextBox z klasy, aby używać i modyfikować dane wejściowe klawiatury.

using System;
using System.Drawing;
using System.Windows.Forms;

namespace KeyboardInput
{
    class Form1 : Form
    {
        // The following Windows message value is defined in Winuser.h.
        private int WM_KEYDOWN = 0x100;
        CustomTextBox CustomTextBox1 = new CustomTextBox();

        [STAThread]
        public static void Main()
        {
            Application.EnableVisualStyles();
            Application.Run(new Form1());
        }

        public Form1()
        {
            this.AutoSize = true;
            this.Controls.Add(CustomTextBox1);
            CustomTextBox1.KeyPress +=
                new KeyPressEventHandler(CustomTextBox1_KeyPress);
        }

        // Consume and modify several character keys.
        void CustomTextBox1_KeyPress(object sender, KeyPressEventArgs e)
        {
            switch (e.KeyChar)
            {
                // Consume 'A' and 'a'.
                case (char)65:
                case (char)97:
                    MessageBox.Show("Control.KeyPress: '" +
                        e.KeyChar.ToString() + "' consumed.");
                    e.Handled = true;
                    break;

                // Detect 'B', modify it to 'A', and forward the key.
                case (char)66:
                    MessageBox.Show("Control.KeyPress: '" +
                        e.KeyChar.ToString() + "' replaced by 'A'.");
                    e.KeyChar = (char)65;
                    e.Handled = false;
                    break;

                // Detect 'b', modify it to 'a', and forward the key.
                case (char)98:
                    MessageBox.Show("Control.KeyPress: '" +
                        e.KeyChar.ToString() + "' replaced by 'a'.");
                    e.KeyChar = (char)97;
                    e.Handled = false;
                    break;
            }
        }
    }
    
    public class CustomTextBox : TextBox
    {
        // The following Windows message value is defined in Winuser.h.
        private int WM_KEYDOWN = 0x100;

        public CustomTextBox()
        {
            this.Size = new Size(100, 100);
            this.AutoSize = false;
        }

        // Detect F1 through F9 during preprocessing and modify F3.
        public override bool PreProcessMessage(ref Message m)
        {
            if (m.Msg == WM_KEYDOWN)
            {
                Keys keyCode = (Keys)m.WParam & Keys.KeyCode;

                // Detect F1 through F9.
                switch (keyCode)
                {
                    case Keys.F1:
                    case Keys.F2:
                    case Keys.F3:
                    case Keys.F4:
                    case Keys.F5:
                    case Keys.F6:
                    case Keys.F7:
                    case Keys.F8:
                    case Keys.F9:

                        MessageBox.Show("Control.PreProcessMessage: '" +
                          keyCode.ToString() + "' pressed.");

                        // Replace F3 with F1, so that ProcessKeyMessage will
                        // receive F1 instead of F3.
                        if (keyCode == Keys.F3)
                        {
                            m.WParam = (IntPtr)Keys.F1;
                            MessageBox.Show("Control.PreProcessMessage: '" +
                                keyCode.ToString() + "' replaced by F1.");
                        }
                        break;
                }
            }

            // Send all other messages to the base method.
            return base.PreProcessMessage(ref m);
        }

        // Detect F1 through F9 during processing.
        protected override bool ProcessKeyMessage(ref Message m)
        {
            if (m.Msg == WM_KEYDOWN)
            {
                Keys keyCode = (Keys)m.WParam & Keys.KeyCode;

                // Detect F1 through F9.
                switch (keyCode)
                {
                    case Keys.F1:
                    case Keys.F2:
                    case Keys.F3:
                    case Keys.F4:
                    case Keys.F5:
                    case Keys.F6:
                    case Keys.F7:
                    case Keys.F8:
                    case Keys.F9:

                        MessageBox.Show("Control.ProcessKeyMessage: '" +
                          keyCode.ToString() + "' pressed.");
                        break;
                }
            }

            // Send all messages to the base method.
            return base.ProcessKeyMessage(ref m);
        }
    }
}

Imports System.Drawing
Imports System.Security
Imports System.Security.Permissions
Imports System.Windows.Forms

Namespace KeyboardInput
    Class Form1
        Inherits Form

        ' The following Windows message value is defined in Winuser.h.
        Private WM_KEYDOWN As Integer = &H100
        Private WithEvents CustomTextBox1 As New CustomTextBox()

        <STAThread()> _
        Public Shared Sub Main()
            Application.EnableVisualStyles()
            Application.Run(New Form1())
        End Sub

        Public Sub New()
            Me.AutoSize = True
            Me.Controls.Add(CustomTextBox1)
        End Sub

        ' Consume and modify several character keys.
        Sub CustomTextBox1_KeyPress(ByVal sender As Object, _
            ByVal e As KeyPressEventArgs) Handles CustomTextBox1.KeyPress

            Select Case e.KeyChar

                ' Consume 'A' and 'a'.
                Case ChrW(65), ChrW(97)
                    MessageBox.Show(("Control.KeyPress: '" + _
                        e.KeyChar.ToString() + "' consumed."))
                    e.Handled = True

                    ' Modify 'B' to 'A' and forward the key.
                Case ChrW(66)
                    MessageBox.Show(("Control.KeyPress: '" + _
                        e.KeyChar.ToString() + "' replaced by 'A'."))
                    e.KeyChar = ChrW(65)
                    e.Handled = False

                    ' Modify 'b' to 'a' and forward the key.
                Case ChrW(98)
                    MessageBox.Show(("Control.KeyPress: '" + _
                        e.KeyChar.ToString() + "' replaced by 'a'."))
                    e.KeyChar = ChrW(97)
                    e.Handled = False
            End Select
        End Sub
    End Class

    Public Class CustomTextBox
        Inherits TextBox

        ' The following Windows message value is defined in Winuser.h.
        Private WM_KEYDOWN As Integer = &H100

        Public Sub New()
            Me.Size = New Size(100, 100)
            Me.AutoSize = False
        End Sub

        ' Detect F1 through F9 during preprocessing and modify F3.
        Public Overrides Function PreProcessMessage(ByRef m As Message) _
            As Boolean

            If m.Msg = WM_KEYDOWN Then
                Dim keyCode As Keys = CType(m.WParam, Keys) And Keys.KeyCode

                ' Detect F1 through F9.
                Select Case keyCode
                    Case Keys.F1, Keys.F2, Keys.F3, Keys.F4, Keys.F5, _
                         Keys.F6, Keys.F7, Keys.F8, Keys.F9

                        MessageBox.Show(("Control.PreProcessMessage: '" + _
                            keyCode.ToString() + "' pressed."))

                        ' Replace F3 with F1, so that ProcessKeyMessage will  
                        ' receive F1 instead of F3.
                        If keyCode = Keys.F3 Then
                            m.WParam = CType(Keys.F1, IntPtr)
                            MessageBox.Show(("Control.PreProcessMessage: '" + _
                                keyCode.ToString() + "' replaced by F1."))
                        End If
                End Select
            End If

            ' Send all other messages to the base method.
            Return MyBase.PreProcessMessage(m)
        End Function

        ' Detect F1 through F9 during processing.
        Protected Overrides Function ProcessKeyMessage(ByRef m As Message) _
            As Boolean

            If m.Msg = WM_KEYDOWN Then
                Dim keyCode As Keys = CType(m.WParam, Keys) And Keys.KeyCode

                ' Detect F1 through F9.
                Select Case keyCode
                    Case Keys.F1, Keys.F2, Keys.F3, Keys.F4, Keys.F5, _
                         Keys.F6, Keys.F7, Keys.F8, Keys.F9

                        MessageBox.Show(("Control.ProcessKeyMessage: '" + _
                            keyCode.ToString() + "' pressed."))
                End Select
            End If

            ' Send all messages to the base method.
            Return MyBase.ProcessKeyMessage(m)
        End Function

    End Class
End Namespace

Kompilowanie kodu

Ten przykład wymaga:

Odwołania do zestawów System, System.Drawing i System.Windows.Forms.

Udostępnij za pośrednictwem