In modernen Browsern wie Chrome oder Edge ist es längst selbstverständlich: Mit Tastenkombinationen wie Alt + 1, Alt + 2, Alt + 3 kann man blitzschnell zwischen geöffneten Tabs springen. Hat man diesen Shortcut einmal verinnerlicht, will man nicht mehr ohne arbeiten. Die Tastenkombinationen sind viel schneller, als wenn man mit der Maus auf den jeweiligen Reiter klickt. Man könnte zwar auch per Strg + Tab zwischen den Seiten wechseln, aber warum nicht direkt zur gesuchten Information springen? Da wir auch in Access standardmäßig eine Ansicht vorfinden, die über entsprechende Reiter angesteuert werden kann, stellt sich die Frage: Können wir nicht auch hier solche Tastenkombinationen nutzen? Genau das untersuchen wir in diesem Beitrag.<\/b><\/p>\n
Alt + 1, Alt + 2, Alt + 3 für Formulare in Registerkartenansicht<\/h2>\n
Access zeigt bei neu angelegten Datenbanken zunächst alle neu erstellten oder geöffneten Elemente als Tab an, der den vollständigen Arbeitsbereich des Access-Fensters einnimmt. Dem einen mag das gefallen, andere bevorzugen die Anzeige als überlappende Fenster. Bevor wir in unsere Lösung einsteigen, schauen wir uns kurz an, wie wir standardmäßig verwendete Einstellungen ändern können.<\/p>\n
Dazu benötigen wir den Dialog mit den Access-Optionen, den wir über Datei|Optionen <\/b>öffnen.<\/p>\n
Hier wechseln wir zum Bereich Aktuelle Datenbank<\/b> und finden dort die Option Dokumentfensteroptionen<\/b> vor (siehe Bild 1).<\/p>\n
![\"Optionen](\"..\/fileadmin\/_temp_\/2025_03\/pic_1550_001.png\")
<\/p>\n
Bild 1: Optionen zum Einstellen der Anzeige von Fenstern innerhalb von Access<\/span><\/b><\/p>\n Der Bereich, in dem sich diese Option befindet, deutet bereits darauf hin, dass es sich um eine Einstellung handelt, die individuell je Datenbank vorgenommen werden kann.<\/p>\n Die aktuelle Standardeinstellung lautet Dokumente im Registerkartenformat <\/b>und zusätzlich ist die Option Dokumentregisterkarten anzeigen <\/b>aktiviert.<\/p>\n Dies führt zu der Anzeige, auf die sich dieser Beitrag bezieht (siehe Bild 2). Wenn wir hier die Option Dokumentregisterkarten anzeigen <\/b>deaktivieren, blendet Access die Registerreiter aus und wir sehen nur das aktuell aktive Formular.<\/p>\n Bild 2: Registerkarten einer Access-Anwendung<\/span><\/b><\/p>\n Sollten wir jedoch die Option Dokumentfensteroptionen<\/b> auf Überlappende Fenster <\/b>einstellen, sehen wir erstens keine Registerreiter für die Fenster.<\/p>\n Wir können die geöffneten Fenster zwar nach wie vor maximieren, aber auch als einzelne Fenster innerhalb des Arbeitsbereichs von Access positionieren. Anwendungen, die das gleichzeitige Anzeigen mehrerer Formulare erfordern, sind mit dieser Einstellung am besten bedient.<\/p>\n Wir wollen uns jedoch auf die Einstellung im Registerkartenformat mit Registerkartenreitern konzentrieren. Die üblicherweise verwendeten Methoden zum Wechseln des aktuell im Vordergrund befindlichen Fensters sind die Folgenden:<\/p>\n Es gibt keine andere eingebaute Methode, Tastenkombinationen wie Strg + 1 <\/b>et cetera betätigen wir ohne jeden Effekt. <\/p>\n Unser Ziel ist es, Alt + 1<\/b> bis Alt + 9<\/b> so zu programmieren, dass bei Betätigen dieser Tastenkombination das entsprechende Formular aktiviert wird – genau wie im Browser.<\/p>\n Unser erster Ansatz ist, jedem Formular eine Ereignisprozedur hinzuzufügen, die auf das Betätigen der entsprechenden Tastenkombination reagiert und den Fokus auf die entsprechende Registerkarte verschiebt.<\/p>\n Damit Access auf Tastatureingaben reagiert, müssen wir die Eigenschaft Tastenvorschau<\/b> aller beteiligten Formulare auf Ja <\/b>einstellen. Das bewirkt, dass alle Tastaturereignisse zuerst an das entsprechende Ereignis des Formulars gesendet werden und nicht etwa an ein Steuerelement, das gerade den Fokus hat.<\/p>\n Diese Einstellung führen wir wie in Bild 3 durch.<\/p>\n Bild 3: Einstellen der Eigenschaft Tastenvorschau auf den Wert Ja<\/span><\/b><\/p>\n Bevor wir überhaupt Code schreiben, der die aktive Registerseite aktivieren soll, müssen wir uns überlegen, wie man eine Registerseite aktiviert. Wir gehen hier davon aus, dass wir die Technik nur für Formulare einsetzen.<\/p>\n Hinter jedem Tab steckt also ein Formular, was bedeutet, dass wir diese über die Forms<\/b>-Auflistung aktivieren können. Probieren wir das aus, sehen wir:<\/p>\n Forms(0).SetFocus <\/b>aktiviert das erste Registerblatt, Forms(1).SetFocus <\/b>das zweite und so weiter. Die Formulare werden also entsprechend der Reihenfolge der Registerseiten indiziert, sodass wir über den 0-basierten Index auf diese zugreifen können.<\/p>\n Nun wollen wir dafür sorgen, dass beim Betätigen einer der Tastenkombinationen Alt + 1 <\/b>bis Alt + 9 <\/b>die entsprechende Registerseite aktiviert wird.<\/p>\n Dazu hinterlegen wir zuerst für das Formular frm1 <\/b>eine Ereignisprozedur, die durch das Ereignis Bei Taste ab <\/b>des Formulars ausgelöst wird.<\/p>\n Dazu wählen wir für die entsprechende Eigenschaft den Eintrag [Ereignisprozedur] <\/b>aus und klicken auf die Schaltfläche mit den drei Punkten (siehe Bild 4).<\/p>\n Bild 4: Anlegen der Ereignisprozedur<\/span><\/b><\/p>\n Dies zeigt die automatisch angelegte, noch leere Ereignisprozedur im VBA-Editor an, die wir wie in Bild 5 ergänzen.<\/p>\n Bild 5: Die fertige Ereignisprozedur<\/span><\/b><\/p>\n Der Code erledigt im Einzelnen die folgenden Schritte:<\/p>\n Hier ist der Code der vollständigen Prozedur:<\/p>\n Diese Prozedur fügen wir nun allen Formularen hinzu, die diese Funktion auslösen sollen. Vergessen Sie nicht, auch für alle betroffenen Formulare die Eigenschaft Tastenvorschau <\/b>auf den Wert Ja <\/b>einzustellen.<\/p>\n Je mehr Formulare diese Funktion erhalten sollen, desto mehr Aufwand bedeutet dies für uns. Wir können den Aufwand zumindest ein wenig verkleinern, indem wir eine Klasse mit dem eigentlichen Code erstellen und diese beim Laden eines Formulars referenzieren.<\/p>\n Die Klasse legen wir unter dem Namen clsTabShortcut <\/b>an und füllen das Klassenmodul mit dem folgenden Code:<\/p>\n Die mit WithEvents <\/b>deklarierte Variable soll einen Verweis auf das Formular aufnehmen, für das wir die entsprechende Ereignisprozedur implementieren wollen. Dieses füllen wir in der öffentlichen Property Set<\/b>-Eigenschaft, der wir beim Laden des Formulars einen Verweis auf das Formular übergeben. Außerdem stellen wir hier die Eigenschaft Tastenvorschau <\/b>auf den Wert Ja <\/b>ein, damit wir das nicht bei jedem einzelnen Formular erledigen müssen.<\/p>\n Außerdem legen wir fest, dass wir in dieser Klasse auf das Ereignis OnKeyDown <\/b>des mit m_Form <\/b>referenzierten Formulars reagieren wollen.<\/p>\n Schließlich legen wir die Ereignisprozedur an, die wir zuvor für jedes einzelne Formular erstellt haben. Diese unterscheidet sich lediglich in Namen, statt Form_KeyDown <\/b>heißt sie m_Form_KeyDown <\/b>entsprechend des Namens der Objektvariablen für das Formular.<\/p>\n Für die Formulare frm1 <\/b>bis frm3 <\/b>behalten wir die bereits angelegte Funktionalität bei. Für die neuen Formulare frm4 <\/b>bis frm6 <\/b>legen wir jeweils eine Ereignisprozedur für das Ereignis Beim Laden <\/b>an.<\/p>\n Im Modulkopf des jeweiligen Formular fügen wir noch eine Variable ein, mit der wir die Instanz der Klasse für dieses Formular referenzieren wollen:<\/p>\n In der Ereignisprozedur Form_Load <\/b>landen nun zwei Anweisungen. Die erste erstellt eine neue Instanz der Klasse clsTabShortcut <\/b>und die zweite weist ihrer Eigenschaft Form <\/b>mit Me <\/b>das aktuelle Formular zu:<\/p>\n Wenn wir nun alle sechs Formulare der Anwendung öffnen, können wir mit den Tastenkombinationen Alt + 1 <\/b>bis Alt + 6 <\/b>die jeweilige Tabseite aktivieren.<\/p>\n Der wesentliche Vorteil dieser Lösung ist: Wir brauchen bei einer eventuellen Änderung des Codes in der Prozedur m_Form_KeyDown <\/b>den Code nur einmal anzupassen und nicht für jedes Formular.<\/p>\n Je nachdem, wie viele Formulare die Datenbank enthält, möchte man sich den Aufwand, jedes Formular mit dem Load<\/b>-Ereignis auszustatten, vielleicht nicht machen.<\/p>\n Also stellen wir noch eine einfachere Lösung vor. Diese basiert darauf, dass wir zu Beginn ein Formular öffnen, das ausgeblendet wird und lediglich die Aufgabe hat, regelmäßig für alle Formulare eine Instanz der Klasse clsTabShortcut zu erstellen, damit die Tastenkombination immer funktioniert.<\/p>\n Die erste Voraussetzung hier ist: Jedes Formular muss dazu ein Klassenmodul enthalten. Wenn ein Formular vorliegt, das keinen Code enthält, können wir das Klassenmodul durch Einstellen der Eigenschaft Enthält Modul <\/b>des jeweiligen Formulars einstellen.<\/p>\n Hat ein Formular kein Modul, wird es schlicht nicht berücksichtigt. Das heißt, es kann zwar über die entsprechende Tastenkombination aktiviert werden, aber es reagiert nicht auf die Eingabe der Tastenkombination.<\/p>\n Wir verwenden wie zuvor die Klasse clsTabShortcut<\/b>. Das Beispiel haben wir in einer neuen Datenbank programmiert, in der die Formulare frm1 <\/b>bis frm6 <\/b>keinen Code enthalten, sondern nur ein leeres Klassenmodul.<\/p>\n Im Formular frmHidden<\/b>, das beim Start geöffnet und gleich ausgeblendet werden soll, hinterlegen wir den folgenden Code. Als Erstes benötigen wir eine Collection<\/b>-Variable namens colForms<\/b>, die alle Instanzen der Klasse clsTabShortcut <\/b>aufnehmen soll:<\/p>\n In der Prozedur, die beim Laden des Formulars ausgelöst wird, öffnen wir zunächst die sechs Beispielformulare, indem wir eine Schleife über die Zahlen 1 <\/b>bis 6 <\/b>durchlaufen und das jeweilige Formular mit DoCmd.OpenForm „frm“ & i <\/b>öffnen. Danach stellen wir das Timer<\/b>-Intervall des Formular auf 1000 <\/b>ein, sodass das Ereignis Form_Timer <\/b>einmal pro Sekunde ausgelöst wird:<\/p>\n Die eigentliche Arbeit übernimmt die Prozedur Form_Timer<\/b>. Diese soll in jeder Sekunde die geöffneten Formulare durchlaufen und für jedes der Formulare eine Instanz der Klasse clsTabShortcut <\/b>erstellen. Dazu durchlaufen wir eine Schleife mit den Werten von 0 <\/b>bis zur Anzahl der Formulare minus 1<\/b>.<\/p>\n In der Schleife erledigt die Prozedur das, was wir zuvor im Form_Load<\/b>-Ereignis jedes einzelnen Formular durchgeführt haben: Wir erstellen eine neue Instanz der Klasse clsTabShortcut <\/b>und weisen ihrer Eigenschaft Form <\/b>einen Verweis auf das aktuell durchlaufene Formular zu. Schließlich müssen die Objektvariablen mit der aktuellen Instanz noch der Collection colForms <\/b>zuweisen, damit diese nicht im Nirwana verschwinden, wenn die Prozedur Form_Timer <\/b>abgeschlossen ist – die Variable objTabShortcut <\/b>ist dort nur lokal deklariert:<\/p>\n Nun müssen wir nur noch dafür sorgen, dass das Formular frmHidden <\/b>bei Start der Anwendung geöffnet und direkt ausgeblendet wird.<\/p>\n Das erledigen wir durch das AutoExec<\/b>-Makro, dem wir den Befehl ÖffnenFormular <\/b>hinzufügen. Hier legen wir für die Eigenschaft Formularname <\/b>den Wert frmHidden <\/b>fest und damit das Formular gar nicht erst angezeigt wird, stellen wir die Eigenschaft Fenstermodus <\/b>auf Ausblendet <\/b>ein (siehe Bild 6).<\/p>\n Bild 6: AutoExec-Formulare zum Öffnen und Ausblenden des Formulars frmHidden<\/span><\/b><\/p>\n Wenn wir die Datenbank nun schließen und erneut öffnen, wird das AutoExec<\/b>-Makro ausgeführt und öffnet das Formular frmHidden<\/b>.<\/p>\n Dieses öffnet die Formulare frm1 <\/b>bis frm6 <\/b>und legt für jedes Formular eine Instanz der Klasse clsTabShortcut <\/b>an.<\/p>\n Diese sorgen dafür, dass jedes der Formulare mit der Tastenkombination ausgestattet wird und die Tastenkombinationen Alt + 1 <\/b>bis Alt + 6 <\/b>dazu führen, dass das jeweilige Registerblatt aktiviert wird.<\/p>\n Der erste Test liefert jedoch eine Überraschung: Wenn wir die Tastenkombination Alt + 1 <\/b>betätigen, erscheint nämlich das Formular frmHidden <\/b>ganz rechts.<\/p>\n Der Grund ist ganz einfach: Das unsichtbare Formular frmHidden<\/b>, das wir gleich zum Start öffnen, wird als das Formular mit dem Index 0 <\/b>in der Forms<\/b>-Auflistung geführt.<\/p>\n Das heißt, dass unsere Reihenfolge durch dieses Formular durcheinandergeworfen wurde. Da wir das Formular frmHidden <\/b>immer als erstes Formular öffnen, wissen wir jedoch auch, dass dieses immer den Index 0 <\/b>erhält.<\/p>\n Das bedeutet, dass die übrigen Formulare einen Index erhalten, der um 1 größer als der aus dem vorherigen Beispiel ist. Also können wir einfach den Code der Prozedur m_Form_KeyDown <\/b>der Klasse clsTabShortcut <\/b>so anpassen, dass der Index des zu aktivierenden Formulars um 1 <\/b>erhöht wird. Dazu stellen wir den von KeyCode <\/b>abzuziehenden Wert auf 48 <\/b>statt <\/b>ein und stellen in der inneren Bedingung Forms.Count + 1 <\/b>ein:<\/p>\n Das funktioniert nun wie gewünscht. Der einzige Fall, indem es nicht mehr funktioniert, ist folgender: Wenn wir beispielsweise frm2 <\/b>ausblenden und es wieder einblenden, wird dieses an der letzten Tab-Position wieder eingefügt. Es behält aber seinen Index, in diesem Fall 2 <\/b>– wir müssten es also nach wie vor über den Forms(2)<\/b> ansprechen.<\/p>\n Das passt allerdings nicht mehr mit der Funktionsweise unserer Tastenkombinationen zusammen, sodass Sie bei Verwendung dieser Lösung ausschließen müssten, dass ein Benutzer ein Formular aus- und wieder einblenden kann.<\/p>\n Das Schließen und erneute Öffnen eines Formulars ist hingegen kein Problem: Hier wird der Index der Formulare mit einem größeren Index als der des gelöschten Formulars einfach angepasst. Das neu geöffnete Formular wird zwar auch als letztes Tab eingefügt, aber es erhält dann auch den größten Indexwert.<\/p>\n Wenn wir das Aus- und Einblenden von Formularen zulassen wollen, müssen wir eine aufwendigere Variante programmieren, die eine ständig aktuelle Liste der sichtbaren Formulare führt und diese aktualisiert, wenn ein ausgeblendetes Formular wieder eingeblendet wird. Auch das ist möglich, würde aber an dieser Stelle den Rahmen sprengen.<\/p>\n Enthaltene Beispieldateien:<\/p>\n AccessRegisterkartenSteuern_Global.accdb<\/p>\n![\"Registerkarten](\"..\/fileadmin\/_temp_\/2025_03\/pic_1550_002.png\")
<\/p>\nWechseln zwischen den Registerkarten<\/h2>\n
\n
Ziel: Alt + 1 bis Alt + 9 aktivieren<\/h2>\n
Vorbereitung<\/h2>\n
![\"Einstellen](\"..\/fileadmin\/_temp_\/2025_03\/pic_1550_003.png\")
<\/p>\nWie kann ich die Tabs gezielt aktivieren?<\/h2>\n
Anlegen der Ereignisprozedur<\/h2>\n
![\"Anlegen](\"..\/fileadmin\/_temp_\/2025_03\/pic_1550_004.png\")
<\/p>\n![\"Die](\"..\/fileadmin\/_temp_\/2025_03\/pic_1550_005.png\")
<\/p>\n\n
Private Sub <\/span>Form_KeyDown(KeyCode As Integer<\/span>, _\r\n Shift As Integer<\/span>)\r\n Dim <\/span>intTab As Integer<\/span>\r\n If <\/span>Shift = acAltMask Then<\/span>\r\n Select Case KeyCode\r\n Case <\/span> To 57\r\n intTab = KeyCode - \r\n If <\/span>intTab < Forms.Count Then<\/span>\r\n Forms(intTab).SetFocus\r\n KeyCode = 0\r\n End If<\/span>\r\n End Select<\/span>\r\n End If<\/span>\r\nEnd Sub<\/span><\/pre>\nViel Aufwand bei vielen Formularen<\/h2>\n
Private <\/span>WithEvents m_Form As <\/span>Form\r\nPublic Property Set<\/span> <\/span>Form(frm As <\/span>Form)\r\n Set<\/span> m_Form = frm\r\n frm.KeyPreview = True<\/span>\r\n m_Form.OnKeyDown = \"[Event Procedure]\"\r\nEnd Property<\/span>\r\nPrivate Sub <\/span>m_Form_KeyDown(KeyCode As Integer<\/span>, _\r\n Shift As Integer<\/span>)\r\n Dim <\/span>intTab As Integer<\/span>\r\n If <\/span>Shift = acAltMask Then<\/span>\r\n Select Case KeyCode\r\n Case <\/span> To 57\r\n intTab = KeyCode - \r\n If <\/span>intTab < Forms.Count Then<\/span>\r\n Forms(intTab).SetFocus\r\n KeyCode = 0\r\n End If<\/span>\r\n End Select<\/span>\r\n End If<\/span>\r\nEnd Sub<\/span><\/pre>\nKlassenfunktion für neue Formulare verfügbar machen<\/h2>\n
Dim <\/span>objTabShortcut As <\/span>clsTabShortcut<\/pre>\nPrivate Sub <\/span>Form_Load()\r\n Set<\/span> objTabShortcut = New<\/span> clsTabShortcut\r\n Set<\/span> objTabShortcut.Form = Me\r\nEnd Sub<\/span><\/pre>\nNoch einfachere Lösung mit Timer<\/h2>\n
Dim <\/span>colForms As <\/span>Collection<\/pre>\nPrivate Sub <\/span>Form_Load()\r\n Dim <\/span>i As Integer<\/span>\r\n For i = 1 To 6\r\n DoCmd.OpenForm \"frm\" & i\r\n Next<\/span> i\r\n Me.TimerInterval = 1000\r\nEnd Sub<\/span><\/pre>\nPrivate Sub <\/span>Form_Timer()\r\n Dim <\/span>lngForm As Long<\/span>\r\n Dim <\/span>objTabShortcut As <\/span>clsTabShortcut\r\n Set<\/span> colForms = New<\/span> Collection\r\n For lngForm = 0 To Forms.Count - 1\r\n Set<\/span> objTabShortcut = New<\/span> clsTabShortcut\r\n With<\/span> objTabShortcut\r\n Set<\/span> .Form = Forms(lngForm)\r\n End With<\/span>\r\n colForms.Add objTabShortcut\r\n Next<\/span> lngForm\r\nEnd Sub<\/span><\/pre>\n![\"AutoExec-Formulare](\"..\/fileadmin\/_temp_\/2025_03\/pic_1550_006.png\")
<\/p>\nPrivate Sub <\/span>m_Form_KeyDown(KeyCode As Integer<\/span>, _\r\n Shift As Integer<\/span>)\r\n Dim <\/span>intTab As Integer<\/span>\r\n If <\/span>Shift = acAltMask Then<\/span>\r\n Select Case KeyCode\r\n Case <\/span> To 57\r\n intTab = KeyCode - 48\r\n If <\/span>intTab < Forms.Count + 1 Then<\/span>\r\n Forms(intTab).SetFocus\r\n KeyCode = 0\r\n End If<\/span>\r\n End Select<\/span>\r\n End If<\/span>\r\nEnd Sub<\/span><\/pre>\nDownloads zu diesem Beitrag<\/h2>\n