<\/p>\n
Kombinationsfelder enthalten viele Einträge, die Sie durch das Aufklappen des Kombinationsfeldes anzeigen und per Mausklick auswählen können. Wenn Sie mit der Tastatur arbeiten, müssen Sie das Kombinationsfeld erst mit der Taste F4 öffnen und dann mit der Nach oben- oder der Nach unten-Taste den gewünschten Eintrag auswählen, den Sie dann durch Verlassen des Steuerelements bestätigen. Das geht auch einfacher, nämlich mit den beiden Tasten „Nach oben“ und „Nach unten“. Es bedarf allerdings einiger Zeilen VBA-Code, die wir in diesem Beitrag vorstellen.<\/b><\/p>\nVorbereitung<\/h2>\n
Um ein Formular mit einem Beispielkombinationsfeld bereitzustellen, legen Sie zunächst ein neues Formular an. Dann legen wir die Tabelle tblArtikel <\/b>aus der Beispieldatenbank Suedsturm <\/b>als Datensatzquelle des Formulars fest. Aktivieren Sie dann die Feldliste und ziehen Sie alle Felder aus der Feldliste in den Detailbereich der Entwurfsansicht des Formulars. Die beiden Felder KategorieID <\/b>und LieferantID <\/b>werden dann direkt als Kombinationsfelder angelegt.<\/p>\n
Für die beiden Kombinationsfelder legen wir die Namen cboLieferantID <\/b>und cboKategorieID <\/b>fest. Speichern Sie das Formular dann unter dem Namen frmKombinatoinsfeldMitTaste<\/b> (siehe Bild 1).<\/p>\n
![\"Beispielformular](\"..\/fileadmin\/_temp_\/2019_01\/pic_1173_001.png\")
<\/p>\n
Bild 1: Beispielformular mit zwei Kombinationsfeldern<\/span><\/b><\/p>\n Wenn Sie in die Formularansicht wechseln, können Sie bei Tastaturbetrieb den Fokus mit der Tabulator-Taste auf eines der Kombinationsfelder verschieben. Dann öffnen Sie dieses mit der Taste F4<\/b> und können dann mit den Tasten Nach oben <\/b>und Nach unten <\/b>einen der Einträge auswählen (siehe Bild 2).<\/p>\n Bild 2: Beispielformular mit zwei Kombinationsfeldern in der Formularansicht<\/span><\/b><\/p>\n Dies wollen wir nun vereinfachen, indem wir das Blättern durch die Einträge ohne öffnen des Kombinationsfeldes ermöglichen. Wie das gelingt, erfahren Sie in den folgenden Abschnitten.<\/p>\n Wir wollen das Verhalten nachbilden, das wir sehen, wenn wir uns bei aufgeklapptem Kombinationsfeld mit der Nach oben<\/b>– und der Nach unten<\/b>-Taste durch die Einträge bewegen. Hier stellen wir fest, dass jeweils der vorherige oder nächste Eintrag ausgewählt wird, sobald der Benutzer eine der beiden Tasten Nach oben <\/b>oder Nach unten <\/b>herunterdrückt.<\/p>\n Damit steht schon einmal das Ereignis fest, dass wir programmieren müssen, nämlich Bei Taste ab<\/b>. Für dieses Ereignis legen wir nun eine Ereignisprozedur an. Diese sieht ohne eigene Anweisungen nun wie folgt aus:<\/p>\n Mit dem Parameter KeyCode <\/b>erhalten wie eine Zahl, welche die soeben gedrückte Taste repräsentiert, Shift <\/b>liefert einen Zahlencode für die Tasten Umschalt<\/b>, Strg <\/b>und Alt<\/b>.<\/p>\n Wir wollen zunächst herausfinden, welche Werte der Parameter KeyCode <\/b>liefert, wenn wir im Kombinationsfeld eine der Tasten Nach oben <\/b>oder Nach unten <\/b>betätigen. Dazu fügen wir die folgende Debug.Print<\/b>-Anweisung zur Ausgabe von KeyCode <\/b>hinzu:<\/p>\n Betätigen wir nun in der Formularansicht die Nach oben<\/b>-Taste, wird der Wert 38 <\/b>im Direktbereich ausgegeben, für die Nach unten<\/b>-Taste der Wert 40<\/b>.<\/p>\n Wir müssen also auf die beiden Werte 38<\/b> und 40 <\/b>reagieren, was wir in einer Select Case<\/b>-Bedingung erledigen.<\/p>\n Die Prozedur sieht danach wie in Listing 1 aus. Sie enthält genau genommen sogar zwei Select Case<\/b>-Bedingungen. Die erste prüft, ob der Benutzer überhaupt eine der beiden Tasten Nach oben <\/b>oder Nach unten <\/b>betätigt hat. In diesem Fall ermitteln wir zunächst den aktuellen Indexwert des Kombinationsfeldes und speichern diesen in der Variablen lngIndex<\/b>.<\/p>\n <\/p>\n Listing 1: Kombinationsfeldeinträge auswählen mit den Nach oben- und Nach unten-Tasten<\/span><\/b><\/p>\n Dann folgt die zweite Select Case<\/b>-Bedingung, in der wir nach den Werten 38 <\/b>(Nach oben<\/b>) und 40 <\/b>(Nach unten<\/b>) unterscheiden.<\/p>\n Im Falle der Taste Nach oben <\/b>prüfen wir, ob der aktuelle Index größer als 0 <\/b>ist. Dazu der Hinweis, dass der Wert der Eigenschaft ListIndex <\/b>bei noch nicht vorhandener Auswahl den Wert -1 <\/b>hat und dass dieser 0-basiert ist.<\/p>\n Ist die Bedingung erfüllt, ziehen wir vom aktuellen Indexwert den Wert 1 <\/b>ab und weisen das Ergebnis der Eigenschaft ListIndex <\/b>des Kombinationsfeldes zu. Somit stellen wir den Index jeweils auf den vorherigen Wert ein und zeigen das jeweils darüber liegende Element an.<\/p>\n In die andere Richtung, also nach unten, sieht es ähnlich aus. Hier prüfen wir, ob der Wert von lngIndex <\/b>noch kleiner ist als die Anzahl der Elemente, ermittelt mit der ListCount<\/b>-Eigenschaft und um 1 <\/b>vermindert. Ist das der Fall, erhöhen wir ListIndex <\/b>einfach um den Wert 1 <\/b>und wechseln damit zum nächsten Element.<\/p>\n Schließlich müssen wir noch den Wert des Parameters KeyCode <\/b>auf 0 <\/b>einstellen, damit das Betätigen der Tasten Nach oben <\/b>und Nach unten <\/b>tatsächlich nur auf das Wechseln der Einträge auswirkt.<\/p>\n Nun wollen wir die gleiche Prozedur für das andere Kombinationsfeld cboKategorieID <\/b>anlegen. Das würde allerdings bedeuten, dass wir den größten Teil der Anweisungen doppelt anlegen. Wenn wir dann später einmal eine Optimierung oder eine andere änderung vornehmen wollen, müssen wir diese an allen betroffenen Stellen durchführen.<\/p>\n Also gliedern wir den Code aus, und zwar nicht einfach in eine eigene Prozedur, sondern gleich in eine Klasse. Diese sieht wie in Listing 2 aus.<\/p>\n Listing 2: Klasse mit den Funktionen zum Blättern in den Kombinationsfeld-Einträgen<\/span><\/b><\/p>\n Um die Klasse neu anzulegen, wählen Sie VBA-Editor den Menüeintrag Einfügen|Klassenmodul <\/b>aus. Die so neu angelegte Klasse speichern Sie mit der Tastenkombination Strg + S<\/b>, und zwar unter dem Namen clsKombinationsfeldPerTaste<\/b>.<\/p>\n Dann fügen Sie zunächst eine Objektvariable hinzu, mit der Sie den Verweis auf das noch zu übergebende Kombinationsfeld speichern:<\/p>\n Um dieses zu füllen, stellen wir im Klassenmodul die folgende öffentliche Property Set<\/b>-Methode zur Verfügung:<\/p>\n Diese Property Set<\/b>-Methode kann in der erzeugenden Prozedur als Eigenschaft des Objekts auf Basis der Klasse verwendet werden. Das dabei zugewiesene Kombinationsfeld wird dann in der privaten Variablen m_ComboBox <\/b>gespeichert.<\/p>\n Für dieses stellen wir dann noch die Eigenschaft OnKeyDown <\/b>auf den Wert [Event Procedure] <\/b>ein. Das ist gleichbedeutend mit dem Einstellen der Eigenschaft Bei Taste ab <\/b>im Eigenschaftenfenster des Steuerelements auf den Wert [Ereignisprozedur]<\/b>.<\/p>\n Die Ereignisprozedur, die wir dafür implementieren, heißt m_ComboBox_KeyDown<\/b>. Sie legen diese am einfachsten an, indem Sie im Codefenster des Klassenmoduls mit dem linken Kombinationsfeld den Wert m_ComboBox <\/b>und mit dem rechten den Wert KeyDown <\/b>auswählen.<\/p>\n Danach erscheint dann der Prozedurrahmen im Codefenster. Der Inhalt dieser Prozedur entspricht weitgehend dem der Prozedur cboLieferantID_KeyDown<\/b>, die wir bereits weiter oben beschrieben haben. Der wesentliche Unterschied ist, dass wir dort nicht mit Me!cboLieferantID <\/b>auf das Kombinationsfeld zugreifen, sondern über m_ComboBox<\/b>.<\/p>\n Wir zeigen am Beispiel des Kombinationsfeldes cboKategorieID<\/b>, wie Sie die Funktion der Klasse für das Kombinationsfeld bereitstellen.<\/p>\n Dabei deklarieren wir zunächst eine Objektvariable für die Klasse clsKombinationsfeldPerTaste <\/b>und nennen diese objKombinationsfeldPerTaste_cboKategorieID<\/b>:<\/p>\n![\"Beispielformular](\"..\/fileadmin\/_temp_\/2019_01\/pic_1173_002.png\")
<\/p>\nKombinations-feld-ein-trag per Taste auswählen<\/h2>\n
Private Sub <\/span>cboLieferantID_KeyDown(KeyCode As Integer<\/span>, Shift As Integer<\/span>)\r\nEnd Sub<\/span><\/pre>\nPrivate Sub <\/span>cboLieferantID_KeyDown(KeyCode As Integer<\/span>, Shift As Integer<\/span>)\r\n Debug.Print<\/span> KeyCode\r\nEnd Sub<\/span><\/pre>\nPrivate Sub <\/span>cboLieferantID_KeyDown(KeyCode As Integer<\/span>, Shift As Integer<\/span>)\r\n Dim <\/span>lngIndex As Long<\/span>\r\n Select Case KeyCode\r\n Case <\/span>38, 40\r\n lngIndex = Me!cboLieferantID.ListIndex\r\n Select Case KeyCode\r\n Case <\/span>38\r\n If <\/span>lngIndex > 0 Then<\/span>\r\n Me!cboLieferantID.ListIndex = lngIndex - 1\r\n End If<\/span>\r\n Case <\/span>40\r\n If <\/span>lngIndex < Me!cboLieferantID.ListCount - 1 Then<\/span>\r\n Me!cboLieferantID.ListIndex = lngIndex + 1\r\n End If<\/span>\r\n End Select<\/span>\r\n KeyCode = 0\r\n End Select<\/span>\r\nEnd Sub<\/span><\/pre>\nCode wiederverwendbar machen<\/h2>\n
Option Compare Database<\/span>\r\nOption Explicit<\/span>\r\nPrivate <\/span>WithEvents m_ComboBox As <\/span>ComboBox\r\nPublic Property Set<\/span> <\/span>ComboBox(cbo As <\/span>ComboBox)\r\n Set<\/span> m_ComboBox = cbo\r\n With<\/span> m_ComboBox\r\n .OnKeyDown = \"[Event Procedure]\"\r\n End With<\/span>\r\nEnd Property<\/span>\r\nPrivate Sub <\/span>m_ComboBox_KeyDown(KeyCode As Integer<\/span>, Shift As Integer<\/span>)\r\n Dim <\/span>lngIndex As Long<\/span>\r\n Select Case KeyCode\r\n Case <\/span>38, 40\r\n lngIndex = m_ComboBox.ListIndex\r\n Select Case KeyCode\r\n Case <\/span>38\r\n If <\/span>lngIndex > 0 Then<\/span>\r\n m_ComboBox.ListIndex = lngIndex - 1\r\n End If<\/span>\r\n Case <\/span>40\r\n If <\/span>lngIndex < m_ComboBox.ListCount - 1 Then<\/span>\r\n m_ComboBox.ListIndex = lngIndex + 1\r\n End If<\/span>\r\n End Select<\/span>\r\n KeyCode = 0\r\n End Select<\/span>\r\nEnd Sub<\/span><\/pre>\nPrivate <\/span>WithEvents m_ComboBox As <\/span>ComboBox<\/pre>\nPublic Property Set<\/span> <\/span>ComboBox(cbo As <\/span>ComboBox)\r\n Set<\/span> m_ComboBox = cbo\r\n With<\/span> m_ComboBox\r\n .OnKeyDown = \"[Event Procedure]\"\r\n End With<\/span>\r\nEnd Property<\/span><\/pre>\nKlasse für Kombinationsfeld implementieren<\/h2>\n
Dim <\/span>objKombinationsfeldMitTaste_cboKategorieID As <\/span> clsKombinationsfeldPerTaste<\/pre>\n