<\/p>\n
![\"Navigieren](\"..\/fileadmin\/_temp_\/2026_06\/pic_1626_005.png\")
<\/p>\n
Bild 1: Navigieren in Formularen per Ribbon<\/span><\/b><\/p>\n Im Beitrag „Datensatznavigation per Ribbon“ (www.access-im-unternehmen.de\/1415) haben wir die Steuerelemente zur Navigation durch die Datensätze aus der Navigationsleiste eines Formulars in das Ribbon verlegt. Damit das Ribbon die Position des Datensatzzeigers anzeigt, enthält das Formular eine Variable und drei Ereignisprozeduren. Diesen Code müssten wir in jedes weitere Formular kopieren, welches das Ribbon anzeigen soll. Wie wir es in eine Klasse auslagern, sodass jedes Formular nur noch eine Variable und eine Prozedur benötigt, zeigt der vorliegende Beitrag.<\/b><\/p>\n Im oben genannten Beitrag haben wir eine praktische Lösung vorgestellt, welche die Elemente der Navigationsleiste eines Formulars direkt im Ribbon anzeigt. Dadurch können wir die eingebauten Elemente durch Setzen von Navigationsschaltflächen <\/b>auf Nein <\/b>ausblenden und stellen dem Benutzer gut sichtbare Steuerelemente zur Verfügung (siehe Bild 1).<\/p>\n Bild 1: Navigieren in Formularen per Ribbon<\/span><\/b><\/p>\n Das Formular frmKunden<\/b> enthält in der Lösung aus dem Vorgängerbeitrag die Variable lngPos<\/b> und die Ereignisprozeduren Form_Current<\/b>, Form_AfterUpdate<\/b> und Form_Delete<\/b>.<\/p>\n Form_Current<\/b> und Form_AfterUpdate<\/b> rufen die Methode Invalidate<\/b> auf, damit das Ribbon seine Elemente aktualisiert. Form_Delete<\/b> speichert die Position des Datensatzzeigers vor dem Löschen eines Datensatzes.<\/p>\n Form_Current<\/b> stellt die Position anschließend wieder her. Die Ribbondefinition und die Bilder übernehmen wir aus dem Vorgängerbeitrag. Die Callbackprozeduren im Modul mdlRibbons<\/b> erweitern wir im Abschnitt Das Formular mit dem Fokus ermitteln<\/b>.<\/p>\n Dieser Code ist in allen Formularen, die das Ribbon verwenden, identisch. Deshalb lagern wir ihn in eine Klasse aus, die auf die Ereignisse des Formulars reagiert. Aus dem Formular frmKunden<\/b> entfernen wir ihn danach.<\/p>\n Dazu deklarieren wir in der Klasse eine Variable des Typs Form<\/b> mit dem Schlüsselwort WithEvents<\/b>. Für diese Variable stellt Access die Ereignisse des Formulars bereit. Dafür können wir Ereignisprozeduren in der Klasse anlegen.<\/p>\n Außerdem muss die jeweilige Ereigniseigenschaft des Formulars den Wert [Event Procedure]<\/b> haben, damit das Formular seine Ereignisse an die Klasse meldet.<\/p>\n Wenn ein Ereignis in einem Formular definiert wurde, wird dies weiterhin ausgeführt und nicht ersetzt. Es feuern dann beide Ereignisse (Klasse und Formular selbst). Das Einstellen erledigt die Klasse selbst, sobald sie das Formular erhält.<\/p>\n Im VBA-Editor legen wir ein neues Klassenmodul an und nennen es clsNavigationWrapper<\/b>. Es beginnt mit zwei Variablen:<\/p>\n Die Variable m_Form<\/b> verweist später auf das Formular und stellt dessen Ereignisse bereit. In der Variablen lngPos<\/b> speichern wir wie im Vorgängerbeitrag die Position des Datensatzzeigers vor dem Löschen eines Datensatzes. Die Klasse erhält das Formular über die Property Set<\/b>-Prozedur Form<\/b>:<\/p>\n Die Prozedur speichert den Verweis auf das Formular in der Variablen m_Form<\/b>. Danach stellt sie die Eigenschaften OnCurrent<\/b>, OnActivate<\/b>, AfterUpdate<\/b>, OnDelete<\/b> und OnClose<\/b> des Formulars auf den Wert [Event Procedure]<\/b> ein.<\/p>\n Mit diesen Werten ruft Access die Ereignisprozeduren der Klasse auf, auch wenn das Formular selbst keine enthält. Das Formular benötigt allerdings ein Klassenmodul, das wir für das Erzeugen der Klasse im Formular anlegen.<\/p>\n Die Ereignisse OnCurrent<\/b>, OnActivate<\/b> und AfterUpdate<\/b> führen zum selben Ergebnis: Das Ribbon soll seine Elemente neu abrufen. Das erledigt die Prozedur RibbonAktualisieren<\/b>:<\/p>\n Die Prozedur ruft die Methode Invalidate<\/b> der Variablen objRibbon_Navigation<\/b> auf. Diese Variable haben wir wie im Vorgängerbeitrag im Modul mdlRibbons<\/b> deklariert.<\/p>\n Zuvor prüft die Prozedur, ob die Variable bereits einen Verweis auf das Ribbon enthält. Beim ersten Öffnen eines Formulars tritt das Ereignis OnCurrent<\/b> nämlich ein, bevor die Prozedur onLoad_Navigation<\/b> die Variable füllt. Der Aufruf der Methode Invalidate<\/b> würde dann einen Fehler auslösen. Wenn mehrere Formulare geöffnet sind, die dasselbe Ribbon verwenden, soll das Ribbon den Zustand des aktiven Formulars anzeigen.<\/p>\n Die Callbackprozeduren im Modul mdlRibbons<\/b> ermitteln das Formular dazu zunächst über die Eigenschaft ActiveForm<\/b> des Objekts Screen<\/b>. Beim Wechsel zu einem anderen Formular tritt das Ereignis OnActivate<\/b> ein. Die Prozedur m_Form_Activate<\/b> aktualisiert dann das Ribbon:<\/p>\n Ohne diese Prozedur zeigt das Ribbon nach dem Wechsel zwischen zwei geöffneten Formularen weiter die Position des zuvor aktiven Formulars an. Das zeigen wir im Abschnitt Das Ribbon in den Formularen prüfen<\/b>.<\/p>\n Damit kommen wir zum Ereignis Beim Anzeigen<\/b>, das wir mit m_Form_Current <\/b>implementieren. Das Textfeld im Ribbon zeigt die Position des Datensatzzeigers und die Anzahl der Datensätze, getrennt durch einen Schrägstrich (\/<\/b>).<\/p>\n Nach dem Löschen eines Datensatzes liefert die Eigenschaft AbsolutePosition<\/b> des Formular-Recordsets zunächst den Wert -1<\/b> oder löst den Fehler 3167<\/b> aus.<\/p>\n Die Prozedur prüft deshalb, ob die Eigenschaft den Wert -1<\/b> hat. Falls ja, stellt sie die Position aus der Variablen lngPos<\/b> wieder her, die die Prozedur m_Form_Delete<\/b> vor dem Löschen gespeichert hat:<\/p>\n Löst das Lesen der Eigenschaft AbsolutePosition<\/b> den Fehler 3167<\/b> aus, setzt VBA die Ausführung wegen On Error Resume Next<\/b> mit der Anweisung im Then<\/b>-Zweig fort.<\/p>\n Die Prozedur stellt die Position damit sowohl bei dem Wert -1<\/b> als auch bei dem Fehler 3167<\/b> wieder her. Die Anweisung On Error Resume Next<\/b> unterdrückt bis zum Ende der Prozedur jeden weiteren Fehler. Würden wir die Position nicht wiederherstellen, zeigte das Textfeld im Ribbon nach dem Löschen die Position 0<\/b> an.<\/p>\n Das Ereignis AfterUpdate<\/b> tritt ein, nachdem der Benutzer einen neuen oder geänderten Datensatz gespeichert hat. Die Prozedur m_Form_AfterUpdate<\/b> gleicht zunächst die Position des Recordsets mit der des Formulars ab und aktualisiert danach das Ribbon:<\/p>\n In den Beispieldaten mit 100 Kunden steht der Datensatzzeiger des Recordsets nach dem Speichern eines neuen Datensatzes noch auf dem bisher letzten Datensatz.<\/p>\n Ohne den Abgleich zeigt das Textfeld im Ribbon deshalb 100\/101<\/b> statt 101\/101<\/b> an.<\/p>\n Für den Abgleich weisen wir der Eigenschaft Bookmark<\/b> des Recordsets das Lesezeichen aus der Eigenschaft Bookmark<\/b> des Formulars zu.<\/p>\n Die Prozedur m_Form_Delete<\/b> speichert die Position des Datensatzzeigers in der Variablen lngPos<\/b>, bevor Access den Datensatz löscht:<\/p>\n Das Formular speichert die Instanz der Klasse in einer Variablen, wie wir im Abschnitt Die Klasse im Formular erzeugen <\/b>zeigen.<\/p>\n Die Instanz verweist über die Variable m_Form<\/b> wiederum auf das Formular.<\/p>\n Damit dieser gegenseitige Verweis nach dem Schließen nicht bestehen bleibt, stellen wir die Variable m_Form<\/b> beim Schließen des Formulars auf den Wert Nothing<\/b> ein:<\/p>\n Die Prozedur onLoad_Navigation<\/b> im Modul mdlRibbons<\/b> weist der Variablen objRibbon_Navigation<\/b> den Verweis auf das Ribbon zu.<\/p>\n Access ruft die Prozedur beim Laden des Ribbons auf. Den Verweis übergibt es im Parameter ribbon<\/b>:<\/p>\n Wir müssen noch klären, wo wir die Klasse instanziieren. Dafür käme die Prozedur onLoad_Navigation<\/b> infrage, die Access beim Laden des Ribbons aufruft. Sie könnte das aktive Formular an eine neue Instanz der Klasse übergeben.<\/p>\n Ob Access die Prozedur für jedes Formular aufruft, prüfen wir mit einer Ausgabe im Direktbereich:<\/p>\n Wir starten Access neu, öffnen das Formular frmKunden<\/b>, schließen es, rufen es erneut auf und starten danach das Formular frmGanzLeer<\/b>. Der Direktbereich enthält nur eine Zeile:<\/p>\n In der Beispieldatenbank ruft Access die Prozedur onLoad_Navigation<\/b> nur beim ersten Öffnen eines Formulars mit diesem Ribbon auf. Danach verwendet Access das geladene Ribbon weiter. Jedes Formular muss deshalb die Instanz der Klasse selbst erzeugen. Die Zeile mit Debug.Print<\/b> entfernen wir wieder.<\/p>\n Zum Erzeugen der Instanz deklarieren wir im Klassenmodul des Formulars die Variable objNavigation<\/b> des Typs clsNavigationWrapper<\/b>. Die Ereignisprozedur Form_Load<\/b> erzeugt darin eine Instanz der Klasse und übergibt ihr mit dem Schlüsselwort Me<\/b> das Formular:<\/p>\n Die Klasse kann die Eigenschaft OnLoad<\/b> nicht selbst einstellen, weil die Instanz der Klasse erst in Form_Load<\/b> entsteht.<\/p>\n Deshalb muss die Eigenschaft OnLoad<\/b> des Formulars den Wert [Event Procedure]<\/b> enthalten. Access trägt ihn ein, wenn wir die Prozedur über das Eigenschaftenblatt des Formulars anlegen, wobei auch das Klassenmodul des Formulars entsteht.<\/p>\n Außer der Eigenschaft RibbonName<\/b> benötigt ein Formular nur den Code aus obigem Listing.<\/p>\n Für jedes weitere Formular, welches das Ribbon anzeigen soll, stellen Sie die Eigenschaft RibbonName<\/b> auf den Wert Navigation<\/b> und die Eigenschaft OnLoad<\/b> auf den Wert [Event Procedure]<\/b> ein. Danach fügen Sie den Code in das Klassenmodul des Formulars ein.<\/p>\n Öffnen wir das Formular frmKunden<\/b> in der Datenblattansicht und markieren den dritten Datensatz, zeigt das Textfeld im Ribbon die Position 3\/100<\/b> an (siehe Bild 2).<\/p>\n Bild 2: Das Ribbon im Formular frmKunden mit dem dritten Datensatz<\/span><\/b><\/p>\n Das Formular frmGanzLeer<\/b> zeigt die leere Tabelle Tabelle1<\/b> an, und die Eigenschaft RecordsetType<\/b> hat den Wert Snapshot<\/b>. Die Datensatzgruppe enthält also keine Datensätze und lässt sich nicht aktualisieren.<\/p>\n Das Ribbon deaktiviert deshalb seine Steuerelemente zur Navigation. Das Textfeld bleibt leer (siehe Bild 3).<\/p>\n Bild 3: Das Ribbon im Formular frmGanzLeer ohne Datensätze<\/span><\/b><\/p>\n Zum Vergleich öffnen wir das Formular frmKunden2<\/b>, eine Kopie des Formulars frmKunden<\/b> mit der Beschriftung Kundenübersicht 2<\/b>. Springen wir in frmKunden<\/b> zum zweiten Datensatz und aktivieren danach frmKunden2<\/b> mit dem ersten Datensatz, zeigt das Ribbon die Position 1\/100<\/b> des aktiven Formulars an (siehe Bild 4).<\/p>\n Bild 4: Das Ribbon zeigt die Position des aktiven Formulars frmKunden2 an<\/span><\/b><\/p>\n Beim Wechsel zurück zu frmKunden<\/b> zeigt das Ribbon die Position 2\/100<\/b> an. Dasselbe gilt, wenn wir frmKunden2<\/b> schließen und damit frmKunden<\/b> aktiv wird. In der Lösung aus dem Vorgängerbeitrag zeigt das Ribbon in beiden Fällen weiter die Position 1\/100<\/b> an. Die Klasse behandelt dafür das Ereignis OnActivate<\/b>.<\/p>\n In den Beispieldaten stimmt die Anzeige im Textfeld auch nach dem Speichern und nach dem Löschen eines Datensatzes mit der Position im Formular überein.<\/p>\n Enthält ein Formular ein Unterformular, muss das Ribbon wissen, für welches der beiden Formulare es die Position anzeigt und in welchem es navigiert.<\/p>\n Wir legen fest, dass das Formular Vorrang hat, in dem sich der Cursor befindet.<\/p>\n Steht er im Hauptformular, bezieht sich das Ribbon auf dessen Datensätze, nach dem Wechsel in das Unterformular auf die Datensätze des Unterformulars. Als Beispiel dient das Formular frmKundenMitBestellungen<\/b>. Es zeigt die Daten eines Kunden aus der Tabelle tblKunden<\/b> in der Einzelansicht und enthält das Unterformular sfrmBestellungen<\/b>.<\/p>\n Dieses zeigt in der Datenblattansicht die Bestellungen des Kunden aus der Tabelle tblBestellungen<\/b>. Die Verknüpfung erfolgt über das Feld KundeID<\/b>.<\/p>\n Bei beiden Formularen können Sie die Eigenschaft NavigationButtons<\/b> nun auf Nein<\/b> einstellen.<\/p>\n Beide Formulare erhalten für die Eigenschaft RibbonName<\/b> den Wert Navigation<\/b>. Das gilt auch für das Unterformular: Ohne diese Einstellung blendet Access beim Wechsel in das Unterformular das Standard-Ribbon ein.<\/p>\n Außerdem enthalten beide Klassenmodule ebenfalls den folgenden Code:<\/p>\n Jedes Formular erzeugt damit seine eigene Instanz der Klasse clsNavigationWrapper<\/b>.<\/p>\n Die Callbackprozeduren im Modul mdlRibbons<\/b> ermitteln das Formular bisher mit Screen.ActiveForm<\/b>. Das liefert das Formular im aktiven Fenster, bei einem Unterformular also das Hauptformular. Die neue Funktion GetNavigationForm<\/b> geht von diesem Formular aus und prüft, ob das aktive Steuerelement ein Unterformular ist. Ist das der Fall, wechselt sie in dessen Formular und wiederholt die Prüfung, damit sie auch verschachtelte Unterformulare erfasst:<\/p>\n Die Variable ctl<\/b> setzen wir vor jedem Durchlauf zurück, weil frm.ActiveControl<\/b> einen Fehler auslöst, wenn kein Steuerelement aktiv ist. In diesem Fall bleibt ctl<\/b> leer, und die Schleife endet. In den Prozeduren getLabel<\/b>, getEnabled<\/b>, getText<\/b> und onAction<\/b> ersetzen wir die Anweisung Set frm = Screen.ActiveForm<\/b> durch Set frm = GetNavigationForm<\/b>. In onChange<\/b> lautet die Anweisung Set rst = GetNavigationForm.Recordset<\/b>.<\/p>\n Listing 1 zeigt die Prozedur getText<\/b>. Alles Weitere bleibt unverändert, weil die Prozeduren mit der Variablen frm<\/b> arbeiten.<\/p>\n Listing 1: Die Prozedur getText verwendet das Formular mit dem Fokus<\/span><\/b><\/p>\n Das Register zeigt außerdem die Eigenschaft Caption<\/b> des Formulars mit dem Fokus an. Damit das Register einen aussagekräftigen Text zeigt, hat das Unterformular für die Eigenschaft Caption<\/b> den Wert Bestellungen<\/b>.<\/p>\n Das Ribbon muss sich auch aktualisieren, wenn der Cursor zwischen Hauptformular und Unterformular wechselt. Das Ereignis Activate<\/b> des Formulars eignet sich dafür nicht, denn es tritt nur ein, wenn ein Formularfenster aktiviert wird.<\/p>\n Stattdessen gibt es die Ereignisse Enter<\/b> und Exit<\/b> des Unterformular-Steuerelements im Hauptformular. Die Klasse deklariert dazu eine weitere Variable des Typs SubForm mit dem Schlüsselwort WithEvents<\/b>:<\/p>\n Die Eigenschaftsprozedur Form<\/b> ermittelt nach dem Einstellen der Formularereignisse mit der Funktion GetSubformControl<\/b>, ob das Formular in einem Unterformular-Steuerelement steckt. Wenn ja, stellt sie dessen Ereigniseigenschaften OnEnter<\/b> und OnExit<\/b> auf [Event Procedure]<\/b> ein:<\/p>\n Die Funktion GetSubformControl<\/b> liest die Eigenschaft Parent<\/b> des Formulars. Bei einem Hauptformular löst Parent<\/b> einen Fehler aus.<\/p>\n Die Funktion bleibt dann leer, und die Variable m_SubformControl<\/b> enthält Nothing<\/b>. Sonst durchläuft sie die Steuerelemente des Hauptformulars und gibt das Unterformular-Steuerelement zurück, dessen Eigenschaft Form<\/b> auf unser Formular verweist.<\/p>\n Damit eignet sich dieselbe Klasse für Haupt- und Unterformulare:<\/p>\n Die beiden Ereignisprozeduren aktualisieren das Ribbon, sobald der Cursor in das Unterformular wechselt oder es verlässt.<\/p>\n Die Aktualisierung läuft erst ab, nachdem der Cursor das Unterformular verlassen hat. Das Ribbon zeigt dann bereits das Formular mit dem neuen Fokus an:<\/p>\n Beim Schließen des Formulars gibt die Klasse neben m_Form<\/b> auch die Variable m_SubformControl<\/b> frei:<\/p>\n In der Einzelansicht liest Access die Datensätze zunächst nur teilweise ein. Die Eigenschaft RecordCount<\/b> liefert dann direkt nach dem Öffnen den Wert 1<\/b>, und das Ribbon zeigt 1\/1<\/b> statt 1\/100<\/b> an.<\/p>\n In der Prozedur m_Form_Current<\/b> steht deshalb vor der Aktualisierung die Anweisung m_Form.RecordsetClone.MoveLast<\/b>. Sie liest alle Datensätze ein, ohne den aktuellen Datensatz des Formulars zu ändern:<\/p>\n<\/p>\nEreignisse des Formulars in einer Klasse behandeln<\/h2>\n
Die Klasse clsNavigationWrapper anlegen<\/h2>\n
Private <\/span>WithEvents m_Form As <\/span>Form\r\nPrivate <\/span>lngPos As Long<\/span><\/pre>\nPublic Property Set<\/span> <\/span>Form(frm As <\/span>Form)\r\n Set<\/span> m_Form = frm\r\n With<\/span> m_Form\r\n .OnCurrent = \"[Event Procedure]\"\r\n .OnActivate = \"[Event Procedure]\"\r\n .AfterUpdate = \"[Event Procedure]\"\r\n .OnDelete = \"[Event Procedure]\"\r\n .OnClose = \"[Event Procedure]\"\r\n End With<\/span>\r\nEnd Property<\/span><\/pre>\nPrivate Sub <\/span>RibbonAktualisieren()\r\n If <\/span>Not<\/span> objRibbon_Navigation Is Nothing Then<\/span>\r\n objRibbon_Navigation.Invalidate\r\n End If<\/span>\r\nEnd Sub<\/span><\/pre>\nPrivate Sub <\/span>m_Form_Activate()\r\n RibbonAktualisieren\r\nEnd Sub<\/span><\/pre>\nPrivate Sub <\/span>m_Form_Current()\r\n On Error Resume Next<\/span>\r\n If <\/span>m_Form.Recordset.AbsolutePosition = -1 Then<\/span>\r\n m_Form.Recordset.AbsolutePosition = lngPos\r\n End If<\/span>\r\n RibbonAktualisieren\r\nEnd Sub<\/span><\/pre>\nPrivate Sub <\/span>m_Form_AfterUpdate()\r\n m_Form.Recordset.Bookmark = m_Form.Bookmark\r\n RibbonAktualisieren\r\nEnd Sub<\/span><\/pre>\nPrivate Sub <\/span>m_Form_Delete(Cancel As Integer<\/span>)\r\n lngPos = m_Form.Recordset.AbsolutePosition\r\nEnd Sub<\/span><\/pre>\nPrivate Sub <\/span>m_Form_Close()\r\n Set<\/span> m_Form = Nothing\r\nEnd Sub<\/span><\/pre>\nDen Verweis auf das Ribbon speichern<\/h2>\n
Sub <\/span>onLoad_Navigation(ribbon As <\/span>IRibbonUI)\r\n Set<\/span> objRibbon_Navigation = ribbon\r\nEnd Sub<\/span><\/pre>\nDie Klasse im Formular erzeugen<\/h2>\n
Sub <\/span>onLoad_Navigation(ribbon As <\/span>IRibbonUI)\r\n Set<\/span> objRibbon_Navigation = ribbon\r\n Debug.Print<\/span> \"onLoad_Navigation fuer \" _\r\n & Screen.ActiveForm.Name\r\nEnd Sub<\/span><\/pre>\nonLoad_Navigation fuer frmKunden<\/pre>\n
Private <\/span>objNavigation As <\/span>clsNavigationWrapper\r\nPrivate Sub <\/span>Form_Load()\r\n Set<\/span> objNavigation = New<\/span> clsNavigationWrapper\r\n Set<\/span> objNavigation.Form = Me\r\nEnd Sub<\/span><\/pre>\nDas Ribbon in den Formularen prüfen<\/h2>\n
![\"Das](\"..\/fileadmin\/_temp_\/2026_06\/pic_1626_006.png\")
<\/p>\n![\"Das](\"..\/fileadmin\/_temp_\/2026_06\/pic_1626_007.png\")
<\/p>\n![\"Das](\"..\/fileadmin\/_temp_\/2026_06\/pic_1626_008.png\")
<\/p>\nDas Ribbon in Unterformularen<\/h2>\n
Private <\/span>objNavigation As <\/span>clsNavigationWrapper\r\nPrivate Sub <\/span>Form_Load()\r\n Set<\/span> objNavigation = New<\/span> clsNavigationWrapper\r\n Set<\/span> objNavigation.Form = Me\r\nEnd Sub<\/span><\/pre>\nDas Formular mit dem Fokus ermitteln<\/h2>\n
Public Function <\/span>GetNavigationForm() As <\/span>Form\r\n Dim <\/span>frm As <\/span>Form\r\n Dim <\/span>ctl As <\/span>control\r\n On Error Resume Next<\/span>\r\n Set<\/span> frm = Screen.ActiveForm\r\n If <\/span>Err.Number = 0 Then<\/span>\r\n Do\r\n Set<\/span> ctl = Nothing\r\n On Error Resume Next<\/span>\r\n Set<\/span> ctl = frm.ActiveControl\r\n On Error GoTo<\/span> 0\r\n If <\/span>ctl Is Nothing Then<\/span> Exit Do<\/span>\r\n If <\/span>Not<\/span> ctl.ControlType = acSubform Then<\/span> Exit Do<\/span>\r\n Set<\/span> frm = ctl.Form\r\n Loop<\/span>\r\n Set<\/span> GetNavigationForm = frm\r\n End If<\/span>\r\nEnd Function<\/span><\/pre>\nSub <\/span>getText(control As <\/span>IRibbonControl, ByRef text)\r\n Dim <\/span>frm As <\/span>Form\r\n Dim <\/span>rst As <\/span>DAO.Recordset\r\n Set<\/span> frm = GetNavigationForm\r\n Set<\/span> rst = frm.Recordset\r\n If <\/span>Not<\/span> rst.Updatable And rst.RecordCount = 0 Then<\/span>\r\n text = \"\"\r\n Else<\/span>\r\n If <\/span>Not<\/span> frm.NewRecord Then<\/span>\r\n text = rst.AbsolutePosition + 1 & \"\/\" & rst.RecordCount\r\n Else<\/span>\r\n text = rst.RecordCount + 1 & \"\/\" & rst.RecordCount + 1\r\n End If<\/span>\r\n End If<\/span>\r\nEnd Sub<\/span><\/pre>\nDie Klasse für Unterformulare erweitern<\/h2>\n
Private <\/span>WithEvents m_Form As <\/span>Form\r\nPrivate <\/span>WithEvents m_SubformControl As <\/span>SubForm\r\nPrivate <\/span>lngPos As Long<\/span><\/pre>\nPublic Property Set<\/span> <\/span>Form(frm As <\/span>Form)\r\n Set<\/span> m_Form = frm\r\n With<\/span> m_Form\r\n .OnCurrent = \"[Event Procedure]\"\r\n .OnActivate = \"[Event Procedure]\"\r\n .AfterUpdate = \"[Event Procedure]\"\r\n .OnDelete = \"[Event Procedure]\"\r\n .OnClose = \"[Event Procedure]\"\r\n End With<\/span>\r\n Set<\/span> m_SubformControl = GetSubformControl\r\n If <\/span>Not<\/span> m_SubformControl Is Nothing Then<\/span>\r\n m_SubformControl.OnEnter = \"[Event Procedure]\"\r\n m_SubformControl.OnExit = \"[Event Procedure]\"\r\n End If<\/span>\r\nEnd Property<\/span><\/pre>\nPrivate Function <\/span>GetSubformControl() As <\/span>SubForm\r\n Dim <\/span>frmParent As <\/span>Form\r\n Dim <\/span>ctl As <\/span>Control\r\n On Error Resume Next<\/span>\r\n Set<\/span> frmParent = m_Form.Parent\r\n On Error GoTo<\/span> 0\r\n If <\/span>frmParent Is Nothing Then<\/span> Exit Function<\/span>\r\n For Each ctl In frmParent.Controls\r\n If <\/span>ctl.ControlType = acSubform Then<\/span>\r\n If <\/span>ctl.Form Is m_Form Then<\/span>\r\n Set<\/span> GetSubformControl = ctl\r\n Exit Function<\/span>\r\n End If<\/span>\r\n End If<\/span>\r\n Next<\/span> ctl\r\nEnd Function<\/span><\/pre>\nPrivate Sub <\/span>m_SubformControl_Enter()\r\n RibbonAktualisieren\r\nEnd Sub<\/span>\r\nPrivate Sub <\/span>m_SubformControl_Exit(Cancel As Integer<\/span>)\r\n RibbonAktualisieren\r\nEnd Sub<\/span><\/pre>\nPrivate Sub <\/span>m_Form_Close()\r\n Set<\/span> m_SubformControl = Nothing\r\n Set<\/span> m_Form = Nothing\r\nEnd Sub<\/span><\/pre>\nPrivate Sub <\/span>m_Form_Current()\r\n On Error Resume