Die Community zu .NET und Classic VB.

Startseite / Tipps / VB.NET-Tipp 0107: Tastencodes verarbeiten - Keys-Enumeration verstehen

VB.NET-Tipp 0107: Tastencodes verarbeiten - Keys-Enumeration verstehen

 von Spatzenkanonier

Schwierigkeitsgrad:

Framework-Version(en): .NET Framework 2.0, .NET Framework 3.0, .NET Framework 3.5

.NET-Version(en): Visual Basic 2005, Visual Basic 2008

Download: Download des Beispielprojektes [21,16 KB]

' Dieser Quellcode stammt von http://www.activevb.de
' und kann frei verwendet werden. Für eventuelle Schäden
' wird nicht gehaftet.

' Um Fehler oder Fragen zu klären, nutzen Sie bitte unser Forum.
' Ansonsten viel Spaß und Erfolg mit diesem Source!

' Projektversion:   Visual Studio 2005
' Option Strict:    An
'
' Referenzen: 
'  - System
'  - System.Data
'  - System.Drawing
'  - System.Web.Services
'  - System.Windows.Forms
'  - System.Xml
'
' Imports: 
'  - Microsoft.VisualBasic
'  - Microsoft.VisualBasic.ControlChars
'  - System
'  - System.Collections
'  - System.Collections.Generic
'  - System.Data
'  - System.Drawing
'  - System.Diagnostics
'  - System.Windows.Forms
'

' ##############################################################################
' ########################### frmKeysEnumeration.vb ############################
' ##############################################################################
Imports System.ComponentModel

Public Class frmKeysEnumeration
    ' Tastendrücke werden hier auf 2 Weisen analysiert:
    '  Einmal werden einfach die relevanten Properties eines gegebenen 
    '   KeyEventArgs angezeigt.
    '  Zum anderen wird eine typisierte Datarow mit entsprechenden Properties 
    '   angezeigt. Die Anzeige erfolgt je im Datagridview (mit nur einer 
    '   Zeile). Das eine ist gebunden an eine BindingList(Of KeyEventArgs), das 
    '   andere an die typisierte DataTable Me.KeyDataSet.Key.

    Private _KeyEventArgsList As New BindingList(Of KeyEventArgs)

    Private Sub frmKeysEnumeration_Load(ByVal sender As Object, _
        ByVal e As EventArgs) Handles MyBase.Load

        Dim Strg_Z As Keys = Keys.Control Or Keys.Z
        ' einfache Analyse: ein KeyEventArgs erstellen, und dessen Properties 
        ' verwenden
        Dim Strg_Z_Args As New KeyEventArgs(Strg_Z)
        ' Strg_Z_Args der DataSource von DataGridView1 zufügen
        _KeyEventArgsList.Add(Strg_Z_Args)
        DataGridView1.AutoGenerateColumns = False
        DataGridView1.DataSource = _KeyEventArgsList
        With Strg_Z_Args
            ' aus Strg_Z_Args eine Datarow erstellen, und der DataSource von 
            ' DataGridView2 zufügen 
            Me.KeyDataSet.Key.AddKeyRow( _
                .Shift, .Control, .Alt, .Modifiers, .Modifiers, _
                .Modifiers >> 16, .KeyData, .KeyData, .KeyCode, .KeyCode)
        End With
    End Sub

    Private Sub frmKeysEnumeration_KeyDown(ByVal sender As Object, _
        ByVal e As KeyEventArgs) Handles MyBase.KeyDown

        ' Steht ein KeyEventArgs zur Verfügung, ist eine Analyse eigentlich 
        '  nicht nötig, weil die Properties des KeyEventArgs alle Informationen 
        '  enthalten. Daher brauche ich auch nur das KeyEventArgs an die 
        '  DataGridView1's DataSource zuzuweisen - schon wird alles angezeigt.
        _KeyEventArgsList(0) = e

        ' Angenommen aber, wir hätten kein KeyEventArgs, nur einen 
        '  Keys-Enumerations-Wert... 
        Dim KeyData As Keys = e.KeyData
        With Me.KeyDataSet.Key(0)
            ' Die Analyse ist einfach: Die unteren 16 Bits repräsentieren die 
            '  Taste (KeyCode), die oberen die Modifiers (Shift, Control, Alt)
            '  Indem man mit Keys.Shift, Keys.Control, oder Keys.Alt maskiert,
            '  erhält man die Aussage, ob der entsprechende Modifier 
            '  gedrückt ist.
            .Shift = CBool(KeyData And Keys.Shift)
            .Control = CBool(KeyData And Keys.Control)
            .Alt = CBool(KeyData And Keys.Alt)

            ' Anzeige typisiert als Keys-Enumerations-Element
            .KeyData = KeyData
            ' Anzeige als Integer
            .KeyDataValue = KeyData

            ' Maskierung mit Hex-Code: Jede Hexadezimal-Ziffer repräsentiert 
            '  4 Bits. 
            ' Die Zahl &HFFFF ist also ein Bitmuster von 16 gesetzten Bits, als 
            '  Maske lässt sie das LowWord eines Int32 passieren. Bei 
            '  &HFFFF0000 dagegen sind die oberen 16 Bits gesetzt, die unteren 
            '  nicht - so maskiert man aufs HighWord eines Int32 

            ' Aufs LowWord maskieren
            .KeyValue = KeyData And &HFFFF
            .KeyCode = KeyData And DirectCast(&HFFFF, Keys)
            ' Anzeige als Integer
            .ModifiersValue = KeyData And &HFFFF0000
            ' Aufs HighWord maskieren
            .Modifiers = KeyData And DirectCast(&HFFFF0000, Keys)
            ' Modifier-Bits (HighWord) aufs "LowWord" schieben
            .SmallModifiers = KeyData >> 16
        End With
    End Sub

End Class