<\/p>\n
Manchmal nervt es einfach, Daten in Textfelder einzugeben, aber in vielen Fällen lässt sich dies nicht ändern. Wenn das Feld numerische Informationen enthält, gibt es aber durchaus Möglichkeiten: Sie können es dann beispielsweise so programmieren, dass der Benutzer den enthaltenen Wert mit den Cursortasten erhöht oder vermindert.<\/b><\/p>\n<\/div>\n Eingabevereinfachung<\/b><\/p>\n Die Eingabe von Daten erfolgt leider immer noch nicht durch Gedankenkraft oder über ein mit dem Gehirn verbundenes USB-Kabel. Bis es so weit ist, sollten Sie Ihren Benutzern diese Arbeit zumindest vereinfachen – einige Anregungen finden Sie in diesem Artikel. Im Einzelnen sieht das folgendermaßen aus, wobei die Cursortasten jedes Mal eine entscheidende Rolle spielen:<\/p>\n Die ersten beiden Beispiele zeigen, wie Sie die Eingabe von Datumsangaben mit verschiedenen Tastenkombinationen erleichtern. üblicherweise gibt man Datumsangaben wie ganz normalen Text ein, manche Anwendungen bieten dazu alternativ ein spezielles Steuerelement an, mit dem sich das Datum per Maus zusammenklicken lässt.<\/p>\n Der Nachteil dieser Lösungen ist aber in der Regel, dass der Benutzer dazu die Maus verwenden muss. Wer schnell arbeiten möchte, sollte sich allerdings auf die Tastatur konzentrieren – das Greifen der Maus, das Anklicken der Schaltfläche zum öffnen des Steuerelements zur Datumseingabe und die Datumseingabe selbst nehmen offensichtlich nicht weniger Zeit in Anspruch als das Eingeben des Datums mit der Tastatur.<\/p>\n Die erste Variante zur Eingabe von Datumsangaben verwendet verschiedene Tastenkombinationen, um die Teile des Datums (Tag, Monat, Jahr) zu ändern.<\/p>\n Die Schaltflächen Cursor nach oben <\/b>und Cursor nach unten <\/b>sind beispielsweise für das ändern des Tages verantwortlich, die Monate und Jahre passt man mit den gleichen Schaltflächen bei gleichzeitig gedrückter Strg<\/b>– und Alt<\/b>-Taste an.<\/p>\n Die zweite Variante kommt nur mit den beiden Tasten Cursor nach oben <\/b>und Cursor nach unten <\/b>aus. Um die verschiedenen Datumselemente zu verändern, positioniert man die Einfügemarke zunächst auf dem entsprechenden Datumsteil und passt diesen dann mit den Cursortasten an.<\/p>\n Auch Zahlen lassen sich in vielen Fällen leichter mit Cursortasten als mit den Zahlentasten selbst verändern.<\/p>\n Das dritte Beispiel zeigt daher, wie Sie die in einem Textfeld enthaltenen Zahlen per Cursortaste nach oben beziehungsweise nach unten korrigieren.<\/p>\n Zuletzt noch ein Beispiel für den Einsatz von Kombinationsfeldern: Wer dort einen neuen Eintrag auswählen möchte, muss dies erst entweder mit der Maus oder durch eine Tastenkombination (entweder F4 <\/b>oder Alt + Cursor nach unten<\/b>) erledigen. Viel schöner wäre es doch, wenn man die in unmittelbarer Umgebung des aktuell ausgewählten Eintrags befindlichen Elemente ganz einfach mit den Tasten Umschalt + Strg + Alt +<\/b> Cursor nach oben <\/b>beziehungsweise Cursor nach unten <\/b>auswählen könnte – und zwar ohne das Aufklappen des Kombinationsfeldes.<\/p>\n Nachteile<\/b><\/p>\n Bei all den nachfolgend vorgestellten Beispielen ist zu berücksichtigen, dass meist die Cursortasten zum Einsatz kommen. Diese dienen üblicherweise zum Wechseln des aktuell markierten Steuerelements.<\/p>\n Dies wird aber ohnehin selbst in den Dialogen der Office-Anwendungen und in Access-Formularen unterschiedlich gehandhabt (Erstere erlauben beispielsweise nicht das Verlassen von Kombinationsfeldern per Cursortaste, Letztere schon).<\/p>\n Wer kann, sollte also am besten die Vorgehensweise seiner Benutzer studieren und gegebenenfalls alternative Steuermöglichkeiten vorsehen, die der Benutzer per Option einstellen kann.<\/p>\n Grundlegendes<\/p>\n Die wichtigste Technik dieses Beitrags ist das Abfangen von Benutzereingaben, und zwar der Cursortasten. Sie müssen erkennen, wann der Benutzer in den entsprechenden Steuerelementen die Cursor nach oben <\/b>und Cursor nach unten<\/b>-Tasten und ihre Kombinationen mit der Umschalt<\/b>-, der Strg<\/b>– und der Alt<\/b>-Taste betätigt. Dabei hilft die Ereignisprozedur Bei Taste ab<\/b>, die jedes Steuerelement bereitstellt. Die passende Ereignisprozedur stellt zwei Parameter zur Verfügung:<\/p>\n Bild 1: Der Objektkatalog liefert bei Bedarf die VB-Konstanten für die KeyCode-Werte.<\/span><\/b><\/p>\n<\/div>\n Wenn Sie nun möchten, dass etwas Spezielles passiert, wenn der Benutzer innerhalb eines Textfeldes die Cursor nach unten<\/b>-Taste drückt, verwenden Sie etwa die folgende Routine:<\/p>\n Sie fragen also über den Parameter KeyCode<\/b> ab, ob der Benutzer die Cursor nach unten<\/b>-Taste betätigt hat, und lassen in diesem Fall den gewünschten Code ausführen.<\/p>\n Wichtig ist, dass Sie dem Parameter KeyCode <\/b>im Anschluss den Wert 0 <\/b>zuweisen, damit Access auch nur die hier angegebene Aktion und nicht die eigentliche durch das Betätigen der Taste ausgelöste Funktion aufruft.<\/p>\n Natürlich kann dies auch gewünscht sein – in diesem Fall lassen Sie die Zeile einfach weg.<\/p>\n Tastenvorschau<\/b><\/p>\n Wie die einzelnen Steuerelemente besitzt auch das Formular ein Bei Taste ab<\/b>-Ereignis. Mit der Eigenschaft Tastenvorschau <\/b>legen Sie fest, ob dieses ausgeführt werden soll. Ist diese Eigenschaft auf Ja <\/b>eingestellt und enthalten sowohl das Formular als auch ein Steuerelement ein Bei Taste ab<\/b>-Ereignis, wird das des Formulars zuerst ausgeführt. Beachten Sie, dass ein Einstellen von KeyCode<\/b> auf den Wert 0 <\/b>sich auch auf das nachfolgend aufgerufene Ereignis des Steuerelements auswirkt.<\/p>\n Textfeldinhalt beeinflussen<\/b><\/p>\n Grundsätzlich gibt man Texte in Textfelder ein, indem man den Fokus auf das Textfeld setzt und dann mit der Tastatur den passenden Wert eintippt. Gegebenenfalls kann man dort natürlich auch Informationen aus der Zwischenablage einfügen.<\/p>\n Wenn das Feld schon einen Wert enthält, muss man diesen erst noch löschen, bevor man den neuen Wert einträgt – dies kann man sich erleichtern, indem man dafür sorgt, dass beim Eintreten in ein Feld direkt der komplette Inhalt markiert wird.<\/p>\n Die Eingabe des ersten neuen Zeichens führt dann dazu, dass der vorhandene Inhalt gelöscht wird (mehr dazu im Beitrag Verhalten beim Feldeintritt<\/b> in der kommenden Ausgabe, Shortlink 540).<\/p>\n Datumseingabe vereinfachen, Variante 1<\/b><\/p>\n Die Eingabe von Datumsangaben können Sie sich bereits mit den richtigen Tastenkombinationen erleichtern (siehe Bild 2).<\/p>\n Bild 2: Die erste Variante der vereinfachten Datumseingabe<\/span><\/b><\/p>\n<\/div>\n Bild 2: Nur mit den Cursortasten ist die Datumseingabe noch intuitiver.<\/span><\/b><\/p>\n<\/div>\n So fügen Strg + Umschalt + , <\/b>das Datum und Strg + Umschalt + . <\/b>die aktuelle Uhrzeit hinzu. Diese Tastenkombinationen kennt aber in der Regel kein normaler Benutzer. Und das Problem ist, dass er auch sämtliche Tastenkombinationen, die Sie für Ihre Steuerelemente vorsehen, nicht kennt. Es gibt also zwei Möglichkeiten:<\/p>\n Letzteres setzt voraus, dass der Benutzer überhaupt von seiner gewohnten Arbeitsweise abweichen möchte, daher können Sie ihm die Vereinfachung natürlich nur anbieten. Das erledigen Sie beispielsweise durch einen entsprechenden Steuerelement-TipText. Bevor Sie das tun, schauen Sie sich allerdings erstmal an, wie man die Datumseingabe überhaupt vereinfachen kann.<\/p>\n Die Routine, die hier durch das Bei Taste Ab<\/b>-Ereignis ausgelöst wird, sieht wie in Listing 1 aus. Sie prüft zunächst, welchen Wert Shift <\/b>liefert, und dann den jeweiligen KeyCode<\/b>. Zuvor prüft die Routine allerdings noch, ob das Textfeld überhaupt einen Wert enthält, und fügt, wenn das nicht der Fall ist, das aktuelle Datum ein. Ist ein Datum vorhanden, wirken sich einige Tastenkombinationen wie folgt aus:<\/p>\n Listing 1: Anpassen des Datums in einem Textfeld nur mit Strg, Alt, Cursor nach oben und Cursor nach unten.<\/p>\n Private Sub txtDatum_KeyDown(KeyCode As Integer, Shift As Integer)<\/p>\n Dim txt As Access.TextBox<\/p>\n If KeyCode = vbKeyUp Or KeyCode = vbKeyDown Then<\/p>\n Set txt = Me!txtDatum<\/p>\n If Len(Nz(txt.Text)) = 0 Then<\/p>\n txt.Text = Date<\/p>\n Else<\/p>\n Select Case Shift<\/p>\n Case 0<\/p>\n Select Case KeyCode<\/p>\n Case vbKeyUp<\/p>\n txt.Text = DateAdd("d", 1, txt.Text)<\/p>\n Case vbKeyDown<\/p>\n txt.Text = DateAdd("d", -1, txt.Text)<\/p>\n End Select<\/p>\n Case acCtrlMask<\/p>\n Select Case KeyCode<\/p>\n Case vbKeyUp<\/p>\n txt.Text = DateAdd("m", 1, txt.Text)<\/p>\n Case vbKeyDown<\/p>\n txt.Text = DateAdd("m", -1, txt.Text)<\/p>\n End Select<\/p>\n Case acAltMask<\/p>\n Select Case KeyCode<\/p>\n Case vbKeyUp<\/p>\n txt.Text = DateAdd("yyyy", 1, txt.Text)<\/p>\n Case vbKeyDown<\/p>\n txt.Text = DateAdd("yyyy", -1, txt.Text)<\/p>\n &<\/p>\n<\/div>\n <\/p>\n Die dabei verwendete Funktion DateAdd <\/b>ist dabei so schlau, dass beispielsweise das Addieren eines Monats zum Datum 31.1.2007 automatisch den 28.2.2007 ergibt.<\/p>\n Wichtig sind hier folgende Aspekte: Arbeiten Sie immer mit der Text<\/b>-Eigenschaft des jeweiligen Wertes. Der Grund ist, dass beispielsweise Me!txtDatum <\/b>eigentlich den Wert der Eigenschaft Me!txtDatum.Value <\/b>liefert. Wenn der Benutzer jedoch den Inhalt des Feldes ändert, ohne das Feld zu aktualisieren, indem er beispielsweise zu einem anderen Feld wechselt oder den Datensatz speichert, besitzt die Eigenschaft Value <\/b>noch immer den Wert, den das Feld zu Beginn hatte. Die Text<\/b>-Eigenschaft gibt immer den angezeigten Inhalt eines Textfeldes aus.<\/p>\n Die Routine prüft zunächst, ob das Textfeld noch leer ist, und fügt gegebenenfalls das aktuelle Datum hinzu (dies ist Geschmackssache; man könnte auch das Datum des vorherigen Datensatzes als Standardwert vorgeben). Anschließend führt sie die Aktion für die jeweilige Tastenkombination aus.<\/p>\n Datumseingabe vereinfachen, Variante 2<\/p>\n Die zweite Variante soll auf zusätzliche Tasten wie die Strg<\/b>– und die Alt<\/b>-Taste verzichten und genau den Datumsteil um eins erhöhen oder vermindern, auf dem sich die Einfügemarke gerade befindet. Zusätzlich soll dieser Teil komplett markiert werden, damit der Benutzer gut erkennen kann, auf welchen Teil sich das Betätigen der Tasten Cursor nach oben <\/b>und Cursor nach unten <\/b>auswirkt. Auch die beiden Tasten Cursor nach links <\/b>und Cursor nach rechts <\/b>werden hier berücksichtigt: Sie sorgen dafür, dass jeweils der benachbarte Teil des Datums angesprungen und markiert wird.<\/p>\n Das ist nicht ganz trivial und bedarf vor allem eines Hinweises: Die Routine aus Listing 2 funktioniert nur, wenn das Kombinationsfeld das deutsche Datumsformat (dd.mm.yyyy) enthält. Für andere Formate sind entsprechende Anpassungen notwendig, eine flexible Variante hätte hier den Rahmen gesprengt.<\/p>\n Listing 2: Einstellen des Datums mit den vier Cursortasten (Teil 1)<\/p>\n Private Sub txtDatumNachPosition_KeyDown(KeyCode As Integer, Shift As Integer)<\/p>\n Dim txt As Access.TextBox<\/p>\n Dim intDatumsteil As eDatumsteil<\/p>\n Dim intPosition As Integer<\/p>\n Dim intTrenner1 As Integer<\/p>\n Dim intTrenner2 As Integer<\/p>\n If KeyCode >= vbKeyLeft And KeyCode <= vbKeyDown Then<\/p>\n Set txt = Me!txtDatumNachPosition<\/p>\n If Len(Nz(txt.Text, "")) = 0 Then<\/p>\n txt.Text = Date<\/p>\n End If<\/p>\n intPosition = txt.SelStart<\/p>\n intTrenner1 = InStr(1, txt.Text, cStrTrennzeichen)<\/p>\n intTrenner2 = InStr(intTrenner1 + 1, txt.Text, cStrTrennzeichen)<\/p>\n Select Case intPosition<\/p>\n Case Is < intTrenner1<\/p>\n intDatumsteil = eTag<\/p>\n Case Is < intTrenner2<\/p>\n intDatumsteil = eMonat<\/p>\n Case Else<\/p>\n intDatumsteil = eJahr<\/p>\n End Select<\/p>\n Select Case KeyCode<\/p>\n Case vbKeyLeft<\/p>\n Select Case intDatumsteil<\/p>\n Case eTag<\/p>\n intDatumsteil = eJahr<\/p>\n txt.SelStart = intTrenner2<\/p>\n txt.SelLength = Len(txt.Text) – intTrenner2 + 1<\/p>\n Case eMonat<\/p>\n intDatumsteil = eTag<\/p>\n txt.SelStart = 0<\/p>\n txt.SelLength = intTrenner1 – 1<\/p>\n &<\/p>\n Case vbKeyUp<\/p>\n Select Case intDatumsteil<\/p>\n Case eTag<\/p>\n txt.Text = DateAdd("d", 1, txt.Text)<\/p>\n txt.SelStart = 0<\/p>\n txt.SelLength = intTrenner1 – 1<\/p>\n Case eMonat<\/p>\n txt.Text = DateAdd("m", 1, txt.Text)<\/p>\n txt.SelStart = intTrenner1<\/p>\n txt.SelLength = intTrenner2 – intTrenner1 – 1<\/p>\n Case eJahr<\/p>\n txt.Text = DateAdd("yyyy", 1, txt.Text)<\/p>\n txt.SelStart = intTrenner2<\/p>\n txt.SelLength = Len(txt.Text) – intTrenner2 + 1<\/p>\n End Select<\/p>\n Case vbKeyRight<\/p>\n Select Case intDatumsteil<\/p>\n Case eTag<\/p>\n intDatumsteil = eMonat<\/p>\n txt.SelStart = intTrenner1<\/p>\n txt.SelLength = intTrenner2 – intTrenner1 – 1<\/p>\n Case eMonat<\/p>\n intDatumsteil = eJahr<\/p>\n txt.SelStart = intTrenner2<\/p>\n txt.SelLength = Len(txt.Text) – intTrenner2 + 1<\/p>\n Case eJahr<\/p>\n &<\/p>\n<\/div>\n Die Routine prüft zunächst, ob der Benutzer eine der vier Cursortasten betätigt hat, und fügt das aktuelle Datum hinzu, falls das Textfeld noch leer ist. Dann ermittelt sie die aktuelle Position der Einfügemarke und die Position der Trennzeichen der einzelnen Datumsteile – hier also des Punktes. Dieses wird übrigens in einer Konstanten gespeichert, damit man gegebenenfalls leicht ein anderes Zeichen einstellen kann:<\/p>\n Das erste Select Case<\/b>-Konstrukt ermittelt, auf welchem Element sich die Einfügemarke gerade befindet. Dazu enthält das Modul spezielle Enumerationskonstanten:<\/p>\n Dann beginnt schon die eigentliche Arbeit – das Auswerten der gedrückten Taste. Falls es sich um die Taste vbKeyLeft <\/b>oder vbKeyRight <\/b>handelt, ermittelt die Routine in einem weiteren Select Case<\/b>-Konstrukt, auf welchem Element sich die Einfügemarke gerade befindet, und verschiebt diese – je nach gedrückter Taste – auf das vorherige oder nachfolgende Element. Befindet sich der Fokus auf dem ersten Element und betätigt der Benutzer die Cursor nach links<\/b>-Taste, wird der Fokus auf das letzte Element, hier also das Jahr, verschoben. Handelt es sich bei der gedrückten Taste um die Cursor nach oben<\/b>– oder Cursor nach unten<\/b>-Taste, prüft die Routine ebenfalls die aktuelle Position der Einfügemarke und erhöht beziehungsweise vermindert die aktuelle Position um eins. Schön wäre natürlich, wenn das Textfeld beim Erhalt des Fokus direkt das erste Element, hier also den Tag, entsprechend markiert. Dafür sorgt die folgende Ereignisprozedur:<\/p>\n Zahleneingabe vereinfachen<\/p>\n Etwas komplizierter, je nach den enthaltenen Werten, ist das Verändern von Zahlen durch entsprechende Tastenkombinationen. Das Erhöhen oder Vermindern des aktuellen Wertes um den Wert 1 <\/b>ist noch das Einfachste und kann etwa so wie in Listing 3 erledigt werden. Auch diese Routine prüft zunächst, ob das Textfeld noch leer ist, und trägt gegebenenfalls den Wert 0 <\/b>ein. Ist der enthaltene Wert nicht numerisch, nimmt die Routine keine änderung vor. Anschließend kann der Benutzer mit den beiden Tasten Cursor nach oben <\/b>und Cursor nach unten <\/b>den Wert jeweils um eins ändern (siehe Bild 4).<\/p>\n Listing 3: Erhöhen und vermindern des aktuellen Zahlenwerts eines Textfelds<\/p>\n Private Sub txtEinfacheZahlen_KeyDown(KeyCode As Integer, Shift As Integer)<\/p>\n Dim txt As Access.TextBox<\/p>\n If KeyCode = vbKeyUp Or KeyCode = vbKeyDown Then<\/p>\n Set txt = Me!txtEinfacheZahlen<\/p>\n If Len(Nz(txt.Text)) = 0 Then<\/p>\n txt = 0<\/p>\n Else<\/p>\n If IsNumeric(txt.Text) Then<\/p>\n Select Case KeyCode<\/p>\n Case vbKeyUp<\/p>\n txt.Text = txt.Text + 1<\/p>\n Case vbKeyDown<\/p>\n txt.Text = txt.Text – 1<\/p>\n End Select<\/p>\n End If<\/p>\n End If<\/p>\n KeyCode = 0<\/p>\n End If<\/p>\n End Sub<\/p>\n<\/div>\n Bild 4: Vergrößern und verkleinern von Zahlen<\/span><\/b><\/p>\n<\/div>\n Die Routine funktioniert so prinzipiell wie gewünscht, allerdings mit einem kleinen Schönheitsfehler: Egal, wo die Einfügemarke sich vor dem Betätigen einer der Cursortasten befindet, sie wird anschließend an den Beginn des enthaltenen Textes gesetzt.<\/p>\n Damit dies nicht passiert, soll sich die Routine merken, wo sich die Einfügemarke zu Beginn befindet, und diese dort anschließend wieder positionieren. Es gibt auch einen Spezialfall: Wenn sich die Einfügemarke am Ende befindet, soll sie sich auch nach dem ändern des Wertes wieder dort befinden.<\/p>\n Das betrifft solche änderungen, welche die Anzahl der Stellen der angezeigten Zahl beeinflussen. Wenn Sie also zum Wert 99 <\/b>die Zahl 1 <\/b>hinzuzählen, soll sich die Einfügemarke anschließend hinter der dritten und nicht hinter der zweiten Stelle befinden. Dies erledigt die modifizierte Variante der Routine, die Sie in Listing 4 finden. Die neu hinzugekommenen Zeilen sorgen dafür, dass sich die Routine die Position der Einfügemarke (SelStart<\/b>) sowie die Anzahl der markierten Zeichen (SelLength<\/b>) merkt. Hat der Benutzer tatsächlich eine der beiden Tasten Cursor nach oben <\/b>oder Cursor nach unten <\/b>betätigt, stellen die letzten Zeilen der Routine den alten Zustand wieder her.<\/p>\n Listing 4: Zahlenwerte ändern unter Beibehaltung der Cursorposition<\/p>\n Private Sub txtEinfacheZahlen_KeyDown(KeyCode As Integer, _ Dim txt As Access.TextBox<\/p>\n Dim intSelStart As Integer<\/p>\n Dim intSelLength As Integer<\/p>\n Dim bolSelEnd As Boolean<\/p>\n Dim bolSelAll As Boolean<\/p>\n If KeyCode = vbKeyUp Or KeyCode = vbKeyDown Then<\/p>\n Set txt = Me!txtEinfacheZahlen<\/p>\n intSelStart = txt.SelStart<\/p>\n intSelLength = txt.SelLength<\/p>\n If intSelStart = Len(txt) Then<\/p>\n bolSelEnd = True<\/p>\n End If<\/p>\n If intSelLength = Len(txt) Then<\/p>\n bolSelAll = True<\/p>\n End If<\/p>\n If Len(Nz(txt.Text)) = 0 Then<\/p>\n txt = 0<\/p>\n Else<\/p>\n If IsNumeric(txt.Text) Then<\/p>\n Select Case KeyCode<\/p>\n Case vbKeyUp<\/p>\n txt.Text = txt.Text + 1<\/p>\n Case vbKeyDown<\/p>\n txt.Text = txt.Text – 1<\/p>\n End Select<\/p>\n End If<\/p>\n End If<\/p>\n If bolSelEnd Then<\/p>\n txt.SelStart = Len(txt.Text)<\/p>\n Else<\/p>\n txt.SelStart = intSelStart<\/p>\n End If<\/p>\n txt.SelLength = intSelLength<\/p>\n If bolSelAll Then txt.SelLength = Len(txt.Text)<\/p>\n KeyCode = 0<\/p>\n End If<\/p>\n End Sub<\/p>\n<\/div>\n Kombinationsfelder mit den Cursortasten steuern<\/b><\/p>\n Die vierte und letzte Technik dieses Beitrags dreht sich um die änderung des aktuell angezeigten Eintrags von Kombinationsfeldern. Dabei soll das Betätigen der Cursor nach oben<\/b>– beziehungsweise Cursor nach unten<\/b>-Schaltfläche bewirken, dass der vorherige beziehungsweise nächste Eintrag ausgewählt wird, ohne das Kombinationsfeld aufzuklappen.<\/p>\n Listing 5 zeigt, wie das funktioniert. Genau wie schon im Textfeld soll auch hier die aktuelle Position der Einfügemarke und eine eventuell vorliegende Markierung beibehalten werden. Damit Access den jeweils vorherigen oder darauffolgenden Eintrag auswählt, muss die Routine zunächst einmal den Index des aktuellen Eintrags ermitteln. Dazu verwendet sie die Eigenschaft ListIndex<\/b>. Um einen neuen Eintrag über den Index auszuwählen (also nicht etwa über den Wert der gebundenen Spalte), ermitteln Sie zunächst den eigentlichen Wert über die Eigenschaft ItemData <\/b>mit dem zuvor ermittelten Index.<\/p>\n Listing 5: Einfaches Auswählen des aktuellen Eintrags in Kombinationsfeldern<\/p>\n Private Sub cboSchnellauswahl_KeyDown(KeyCode As Integer, _ Dim intSelStart As Integer<\/p>\n Dim intSelLength As Integer<\/p>\n Dim bolSelEnd As Boolean<\/p>\n Dim bolSelAll As Boolean<\/p>\n Dim cbo As Access.ComboBox<\/p>\n If (KeyCode = vbKeyUp Or KeyCode = vbKeyDown) And Shift = 0 Then<\/p>\n Set cbo = Me!cboSchnellauswahl<\/p>\n intSelStart = cbo.SelStart<\/p>\n intSelLength = cbo.SelLength<\/p>\n If intSelStart = Len(cbo) Then<\/p>\n bolSelEnd = True<\/p>\n End If<\/p>\n If intSelLength = Len(cbo) Then<\/p>\n bolSelAll = True<\/p>\n End If<\/p>\n Select Case KeyCode<\/p>\n Case vbKeyUp<\/p>\n If Nz(cbo, 0) = 0 Then<\/p>\n cbo = cbo.ItemData(0)<\/p>\n Else<\/p>\n If cbo > -1 And Not cbo.ListIndex = 0 Then<\/p>\n cbo = cbo.ItemData(cbo.ListIndex – 1)<\/p>\n End If<\/p>\n End If<\/p>\n Case vbKeyDown<\/p>\n If Nz(cbo, 0) = 0 Then<\/p>\n cbo = cbo.ItemData(0)<\/p>\n Else<\/p>\n If cbo > -1 And Not cbo.ListIndex = _ cbo = cbo.ItemData(cbo.ListIndex + 1)<\/p>\n End If<\/p>\n<\/div>\n Von der Ereignisprozedur zur eigenständigen Routine<\/b><\/p>\n Was im Beispielformular in Form von Ereignisprozeduren gut funktioniert, wird natürlich unübersichtlich, wenn Sie es an allen möglichen Stellen integrieren. Daher sollten Sie die betroffenen Codezeilen in eigenen Routinen in einem Standardmodul unterbringen. Am Beispiel der Funktion zum ändern des in einem Textfeld enthaltenen Datums mit den vier Cursortasten sieht das wie folgt aus: Zunächst erstellen Sie eine leere Funktion, die einen Verweis auf das betroffene Steuerelement erwartet. Diese Funktion enthält prinzipiell den gleichen Code wie die Ereignisprozedur und sieht schließlich so aus:<\/p>\n Die zwei wesentlichen Unterschiede zur Ereignisprozedur sind folgende:<\/p>\n Der Aufruf in der Ereignisprozedur sieht dann beispielsweise so aus:<\/p>\n Dadurch, dass der Parameter KeyCode <\/b>standardmäßig als Referenz auf den passenden Wert an die Prozedur übergeben wird, wirken sich änderungen auch auf die entsprechende Variable der aufrufenden Prozedur aus.<\/p>\n Zusammenfassung und Ausblick<\/b><\/p>\n Dieser Artikel zeigt nur einige von vielen Möglichkeiten zur Optimierung der Funktionsweise von Steuerelementen. Diese können Sie je nach Arbeitsweise so in eigene Anwendungen übernehmen oder müssen sie entsprechend anpassen – wenn Sie etwa die hier verwendeten Tastenkombinationen schon benutzen, finden Sie sicher eine andere, sinnvolle Art, die Funktionen anzusprechen.<\/p>\n Wenn Sie ein Standardmodul bauen, das alle Routinen für den Einsatz mit Steuerelementen enthält, können Sie dieses leicht in andere Datenbanken einfügen und die Funktionen auch in den dortigen Steuerelementen einsetzen. Die Funktionen müssen außerdem hier und da noch durch Fehlerbehandlungen und zusätzliche Validierungen stabiler gemacht werden. Die Funktion zum ändern der Elemente eines Datums über die Cursortasten erlaubt beispielsweise auch die Eingabe von Tag, Monat und Jahr über die üblichen Zahlentasten. Wenn der Benutzer hier unsinnige Werte eingibt, kann das schnell zu Problemen führen – das Erhöhen des Datums 1.13.2007 führt so beispielsweise direkt zu einem Fehler. Dies lässt sich aber mit wenigen zusätzlichen Zeilen ausbügeln.<\/p>\n Enthaltene Beispieldateien:<\/p>\n Steuerelementoptimierung.mdb<\/p>\n\n\n
\n ![\"abb001.tif\"](\"..\/fileadmin\/_temp_\/2007_05\/TextfelderMitCursortasten-web-images\/abb001_opt.jpeg\")
\n<\/div>\n\nPrivate Sub txtBeispiel_KeyDown(KeyCode _
As Integer, Shift As Integer)\r\n If KeyCode = vbKeyDown Then\r\n 'Do something\r\n KeyCode = 0\r\n End If\r\nEnd Sub<\/pre>\n\n ![\"abb002.tif\"](\"..\/fileadmin\/_temp_\/2007_05\/TextfelderMitCursortasten-web-images\/abb002_opt.jpeg\")
\n<\/div>\n\n\n ![\"abb003.tif\"](\"..\/fileadmin\/_temp_\/2007_05\/TextfelderMitCursortasten-web-images\/abb003_opt.jpeg\")
\n<\/div>\n\n\n
\n\n
\nConst cStrTrennzeichen As String = "."<\/pre>\n
Enum eDatumsteil\r\n eTag = 0\r\n eMonat = 1\r\n eJahr = 2\r\nEnd Enum<\/pre>\n
Private Sub txtDatumNachPosition_GotFocus()\r\n Dim txt As Access.TextBox\r\n Set txt = Me!txtDatumNachPosition\r\n If IsDate(txt) Then\r\n txt.SelStart = 0\r\n txt.SelLength = _
InStr(1, txt, _
cStrTrennzeichen) _
- 1\r\n End If\r\nEnd Sub<\/pre>\n\n\n ![\"abb004.tif\"](\"..\/fileadmin\/_temp_\/2007_05\/TextfelderMitCursortasten-web-images\/abb004_opt.jpeg\")
\n<\/div>\n\n\n
Shift As Integer)<\/p>\n\n
Shift As Integer)<\/p>\n
cbo.ListCount – 1 Then<\/p>\nPublic Sub ChangeDateWithCursor(KeyCode As _
Integer, Shift As Integer, _
txt As Access.TextBox)\r\n ...\r\nEnd Sub<\/pre>\n\n
Private Sub txtDatumMitFunktion_KeyDown _
(KeyCode As Integer, Shift As Integer)\r\n ChangeDateWithCursor KeyCode, _
Shift, Me!txtDatumMitFunktion\r\nEnd Sub<\/pre>\nDownloads zu diesem Beitrag<\/h3>\n