<\/p>\n
![\"Daten](\"..\/fileadmin\/_temp_\/2023_01\/pic_1415_001.png\")
<\/p>\n
Bild 1: Daten in der Datenblattansicht<\/span><\/b><\/p>\n Die Navigationszeile am unteren Rand von Formularen oder Unterformularen in der Datenblattansicht ist recht fummelig und fällt nicht auf den ersten Blick auf, wenn man nicht gewohnt ist, damit zu arbeiten. Es gibt eine Menge Lösungen, bei denen diese Steuerelemente in Form von Formular-Schaltflächen bereitgestellt werden. Uns ist aber noch keine Lösung über den Weg gelaufen, bei der die Navigationssteuerelemente im Ribbon abgebildet wurden. Zwar gibt es einen eigenen Bereich, der Werkzeuge für den Umgang mit der Datenblattansicht bereitstellt, aber dieser bietet keine Steuerelemente zum Navigieren in den Datensätzen. Aber kein Problem: Wir liefern das nach!<\/b><\/p>\n Wenn wir eine Tabelle in einem Formular in der Datenblattansicht anzeigen wie in Bild 1, sehen wir am unteren Rand des Formulars die Navigationssteuerelemente – also Schaltflächen und ein Textfeld mit den folgenden Funktionen:<\/p>\n Bild 1: Daten in der Datenblattansicht<\/span><\/b><\/p>\n Es wäre doch praktisch, wenn diese wichtigen Steuerelemente nicht klein und ganz unten angezeigt würden, sondern oben prominent im Ribbon – sodass der Benutzer diese nicht übersehen kann!<\/p>\n Also schauen wir uns in diesem Beitrag an, wie wir dies realisieren können.<\/p>\n Da wir das Verhalten der oben genannten Steuerelemente möglichst genau abbilden wollen, müssen wir es zunächst studieren. In der Regel öffnet man ein Formular mit Daten und erhält den ersten Datensatz der Datensatzquelle. In diesem Zustand sind alle Steuerelemente mit Ausnahme der Schaltfläche zum Anzeigen des vorherigen Datensatzes aktiviert. Das ergibt Sinn, denn man kann nicht zu einem früheren Datensatz springen, wenn schon der erste Datensatz angezeigt wird. Aber kann man zum ersten Datensatz springen, wenn schon der erste angezeigt wird? Man könnte sich streiten, ob die Schaltfläche zum Ansteuern des ersten Datensatzes aktiviert sein muss, wenn der erste Datensatz angezeigt wird, aber Tatsache ist: Unter Access ist es so.<\/p>\n Die nächste zu untersuchende Situation ist die, wenn sich der Datensatzzeiger irgendwo zwischen dem ersten und dem letzten Datensatz befindet. Hier sind immer alle Schaltflächen aktiviert.<\/p>\n Das ist auch bei der Anzeige des letzten Datensatzes der Fall! Warum aber ist hier die Schaltfläche zum Anzeigen des nächsten Datensatzes aktiviert, obwohl wir ja eigentlich nicht mehr zu einem weiteren Datensatz springen können?<\/p>\n Ganz einfach: Unter Access können wir in dieser Situation noch zu einem neuen, leeren Datensatz springen, wenn wir diese Schaltfläche anklicken.<\/p>\n Eine Situation führt übrigens dazu, dass auch die Schaltfläche zum Anzeigen eines neuen Datensatzes einmal deaktiviert ist: dann nämlich, wenn das Formular Daten anzeigt, die nicht aktualisierbar sind.<\/p>\n Und dann wird auch die Schaltfläche zum Anzeigen des nächsten Datensatzes deaktiviert, wenn sich der Datensatzzeiger auf dem letzten Datensatz befindet.<\/p>\n Dieses Verhalten können wir für ein Formular übrigens relativ einfach abbilden – wir müssen dazu nur die Eigenschaft Recordsettyp <\/b>auf Snapshot <\/b>einstellen oder eine nicht aktualisierbare Abfrage zusammenstellen.<\/p>\n Die hier definierten Regeln wollen wir beim Programmieren der Ribbonanpassung zum Steuern der Datensatzanzeige berücksichtigen.<\/p>\n Das geplante Ribbon soll wie in Bild 2 aussehen. Es enthält also fünf Schaltflächen sowie ein EditBox<\/b>-Element, das die aktuelle Position des Datensatzzeigers anzeigt und auch die Eingabe einer neuen Position erlaubt.<\/p>\n Bild 2: So soll das Ribbon zur Datensatznavigation aussehen.<\/span><\/b><\/p>\n Was wir hier nicht beschreiben, aber dennoch benötigt wird und in der Beispieldatenbank enthalten ist:<\/p>\n Davon ab nutzen wir eine Tabelle namens USysRibbons<\/b>, in der wir die Ribbondefinition im XML-Format speichern.<\/p>\n Diese enthält drei Felder, nämlich RibbonID <\/b>(Primärschlüsselfeld mit Autowert), RibbonName <\/b>(Datentyp Kurzer Text<\/b>) und RibbonXML <\/b>(Datentyp Langer Text<\/b>). Darin speichern wir die nötigen Informationen wie in Bild 3.<\/p>\n Bild 3: Tabelle zum Speichern der Ribbondefinition<\/span><\/b><\/p>\n Nun schauen wir uns die darin enthaltene Ribbondefinition an. Diese haben wir in Listing 1 abgebildet. Das Element customUI <\/b>enthält die beiden Attribute onLoad <\/b>und loadImage<\/b>, welche die beim Laden des Ribbons und für die Anzeige von Bildern benötigten VBA-Prozeduren angeben. Die für onLoad <\/b>hinterlegte Prozedur OnLoad_Navigation <\/b>wird direkt beim Laden ausgelöst, die für loadImage <\/b>hinterlegte für jedes Element, welches das Attribut image <\/b>aufweist und somit ein Bild anzeigen soll.<\/p>\n Listing 1: Definition des Ribbons für die Datensatznavigation<\/span><\/b><\/p>\n Wenn wir zur Laufzeit die Eigenschaften von Ribbonelementen aktualisieren wollen, was hier absehbar ist, weil Schaltflächen aktiviert und deaktiviert werden sollen und auch das editBox<\/b>-Element die jeweilige Position des Datensatzzeigers anzeigen soll, müssen wir eine Variable des Typs IRibbonUI <\/b>deklarieren. Dieses bietet die Methode Invalidate <\/b>an, mit der wir dafür sorgen können, dass die Attribute wie getEnabled<\/b>, getText <\/b>et cetera ihre Werte per Callbackprozedur erneut abrufen. Diese Variable deklarieren wir wie folgt:<\/p>\n Außerdem implementieren wir die für das Attribut onLoad<\/b> hinterlegte Prozedur wie folgt, damit diese mit der Variablen objRibbon_Navigation <\/b>gleich beim Laden einen Verweis auf die angewendete Ribbondefinition hinterlegt:<\/p>\n Unterhalb des customUI<\/b>-Elements befinden sich die obligatorischen ribbon<\/b>-, tabs<\/b>– und tab<\/b>-Elemente. Das tab<\/b>-Element mit der Bezeichnung tabNavigation <\/b>enthält das Callback-Attribut getLabel<\/b>, welches die Beschriftung des tab<\/b>-Elements ermitteln soll. Diese Beschriftung soll entweder den Wert der Eigenschaft Beschriftung <\/b>des Formulars enthalten oder, wenn diese nicht angegeben wurde, den Namen des Formulars als tab<\/b>-Beschriftung anzeigen.<\/p>\n Die für das Attribut getLabel <\/b>hinterlegte Prozedur wird direkt beim Anzeigen des Ribbons aufgerufen und sieht wie folgt aus:<\/p>\n Sie prüft per Select Case<\/b>, ob sie für das Element tabNavigation <\/b>aufgerufen wurde und referenziert dann das aktuelle Formular. Wenn wir, wie geplant, diese Ribbondefinition als Ribbon für ein Formular angeben, ist auf jeden Fall ein Formular geöffnet, wenn das Ribbon erscheint. Für dieses prüfen wir dann, ob die Eigenschaft Caption <\/b>leer ist. Ist das der Fall, gibt die Prozedur den Namen des Formulars zurück, anderenfalls die Beschriftung aus der Eigenschaft Caption<\/b>.<\/p>\n Unter dem tab<\/b>-Element folgt das group<\/b>-Element, das die eigentlichen Steuerelemente enthält. Die button<\/b>-Elemente erhalten jeweils den Namen des anzuzeigenden Icons für das image<\/b>-Attribut, zum Beispiel navigate_beginning<\/b>. Außerdem zeigen sie eine Beschriftung an, die wir für das Attribut label <\/b>angeben und ein eindeutiger Bezeichner, der im Attribut id <\/b>landet, darf auch nicht fehlen.<\/p>\n Schließlich enthält jedes button<\/b>-Element noch zwei Attribute, für die wir VBA-Prozeduren hinterlegen:<\/p>\n In einem Textfeld wollen wir einen Wert wie 1\/100 <\/b>anzeigen und somit die Position des Datensatzzeigers sowie die Anzahl der Datensätze darstellen. Das erledigen wir mit einem editBox<\/b>-Element. Für dieses hinterlegen wir auch drei Callback-Attribute:<\/p>\n Die fünf Bilddateien, welche die Schaltflächen als Icon anzeigen sollen, speichern wir in der Tabelle MSysResources<\/b>. Um diese dort zu hinterlegen, gibt es einen einfachen Trick: Wir zeigen ein Formular in der Entwurfsansicht an, klicken auf den Ribbonbefehl zum Hinzufügen eines Bild-Steuerelements, wählen das Bild mit dem dann erscheinenden Dateiauswahl-Dialog aus und brechen dann das Hinzufügen des Bild-Steuerelements ab.<\/p>\n Damit legen wir zwar kein Bild-Steuerelement an, aber das soeben ausgewählte Bild wird in der Tabelle MSysResources <\/b>gespeichert. Diesen Schritt wiederholen wir einfach für alle anzuzeigenden Bilder, bis die Tabelle MSysResources <\/b>wie in Bild 4 aussieht. Diese Tabelle wird im Navigationsbereich übrigens nur erscheinen, wenn die Anzeige von Systemobjekten und ausgeblendeten Objekten aktiviert ist. Man kann sie aber auch mit dem folgenden Befehl öffnen (das gilt auch für die Tabelle USysRibbons<\/b>):<\/p>\n [<\/p>\n Bild 4: Tabelle zum Speichern der Bilder, die als Icons der Schaltflächen im Ribbon erscheinen sollen<\/span><\/b><\/p>\n Für die Tabelle USysRibbons <\/b>analog:<\/p>\n Das die Bilder letztlich angezeigt werden, erreichen wir durch die Kombination der Angabe des Wertes aus dem Feld Name <\/b>für das Attribut image <\/b>der button<\/b>-Elemente sowie der Verwendung der für das Attribut loadImage <\/b>des customUI<\/b>-Elements hinterlegten Callbackprozedur.<\/p>\n Damit das editBox<\/b>-Element einen Text wie 1\/100 <\/b>anzeigt und diese Anzeige zu gegebenen Zeitpunkten aktualisiert, müssen wir eine entsprechende Callbackprozedur hinterlegen. Diese sieht wie folgt aus:<\/p>\n Die Prozedur referenziert das aktuell im Fokus befindliche Formular mit der Variablen frm <\/b>und das darin enthaltene Recordset mit rst<\/b>. Dann prüft die Prozedur, ob das Recordset nicht aktualisierbar ist und keinen Datensatz enthält. In diesem Fall soll das editBox<\/b>-Element keinen Wert anzeigen.<\/p>\n Anderenfalls folgt die Unterscheidung, ob das Formular gerade keinen neuen Datensatz anzeigt oder einen neuen. Im ersteren Fall ermittelt die Prozedur mit rst.AbsolutePosition + 1 <\/b>die aktuelle Position des Datensatzzeigers und mit rst.RecordCount <\/b>die Anzahl der Datensätze. Diese beiden Werte fügt sie, durch einen Schrägstrich voneinander getrennt, zusammen und gibt sie mit dem Parameter text <\/b>an das aufrufende Steuerelement zurück. Falls das Formular gerade einen neuen, leeren Datensatz anzeigt, stellen wir den Inhalt des Textfeldes auf den Ausdruck rst.RecordCount + 1 & „\/“ & rst.RecordCount + 1<\/b> ein – also wenn es 100 Recordsets enthält, auf 101\/101<\/b>. Wie und wann wir die Anzeige aktualisieren, zeigen wir in wenigen Abschnitten.<\/p>\n Für jede der fünf Schaltflächen haben wir mit dem Attribut getEnabled <\/b>den Namen der Callbackprozedur hinterlegt, mit der wir den Enabled<\/b>-Zustand der jeweiligen Schaltfläche ermitteln wollen. Diese Prozedur sieht wie in Listing 2 aus. Sie nimmt mit dem Parameter control <\/b>einen Verweis auf das auslösende Steuerelement entgegen und erwartet für den Parameter enabled <\/b>die Angabe des Wertes True <\/b>oder False<\/b>.<\/p>\n Listing 2: Die Prozedur getEnabled zum Ermitteln des enabled-Zustands der Schaltflächen<\/span><\/b><\/p>\n Die Prozedur referenziert mit der Variablen frm <\/b>das aktuell angezeigte und mit Screen.ActiveForm <\/b>ermittelte Formular sowie mit rst <\/b>das darin enthaltene Recordset. Das setzt voraus, das aktuell ein Formular angezeigt wird – was erfüllt ist, da das Ribbon nur in Zusammenhang mit einem Formular geöffnet wird. Ein Recordset sollte auch vorliegen, sonst macht die Zuweisung dieses Ribbons keinen Sinn.<\/p>\n Danach prüft die Prozedur mit dem Wert der Eigenschaft ID <\/b>des mit control <\/b>gelieferten IRibbonControl<\/b>-Elements, für welches Steuerelement die Prozedur aufgerufen wurde.<\/p>\n Für die Schaltfläche btnErster <\/b>ist der Fall klar: Sie soll eigentlich immer aktiviert sein, also könnten wir mit dem Parameter enabled <\/b>den Wert True <\/b>zurückgeben. Das Gleiche gilt für die Schaltfläche btnLetzter<\/b>.<\/p>\n Aber es gibt einen Sonderfall: Wenn wir nämlich auf ein Formular stoßen, dessen Recordset leer ist und wenn gleichzeitig die Bearbeitung der Daten deaktiviert ist, dann sind die original Navigationsschaltflächen ebenfalls deaktiviert. Also fragen wir ab, ob rst.RecordCount <\/b>gleich 0 <\/b>ist und rst.Updatable <\/b>gleich False<\/b>. Ist beides wahr, sollen die Schaltflächen btnErster <\/b>und btnLetzter <\/b>deaktiviert werden.<\/p>\n Für die Aktivierung der Schaltfläche btnVorheriger <\/b>prüfen wir, ob der Datensatzzeiger sich auf der ersten Position befindet – und zwar mit rst.AbsolutePosition = 0<\/b>. Ist dies wahr, gibt es keinen vorherigen Datensatz mehr – also soll diese Schaltfläche deaktiviert werden. In allen anderen Fällen ist sie aktiviert.<\/p>\n Bei der Schaltfläche btnNaechster <\/b>gelten etwas andere Regeln, denn auch wenn wir uns bereits auf dem letzten Datensatz befinden, soll diese Schaltfläche es ermöglichen, zu einem neuen, leeren Datensatz zu springen. Außer natürlich, die Datensatzgruppe kann nicht aktualisiert werden – dann soll btnNaechster <\/b>bei Anzeige des letzten Datensatzes nicht aktiviert sein. Und wenn sich der Datensatzzeiger auf einem neuen, noch nicht gespeicherten Datensatz befindet, soll die Schaltflächen btnNaechster<\/b> auch deaktiviert werden.<\/p>\n Wir prüfen also als Erstes mit Not frm.NewRecord<\/b>, ob kein neuer, leerer Datensatz angezeigt wird. Dann prüfen wir, ob wir uns auf dem letzten Datensatz befinden.<\/p>\n Ist das der Fall und das Recordset ist aktualisierbar, aktivieren wir die Schaltfläche. Falls wir auf dem letzten Datensatz sind und das Recordset ist nicht aktualisierbar, deaktivieren wir btnNaechster<\/b>.<\/p>\n Befinden wir uns nicht auf dem letzten Datensatz, aktivieren wir btnNaechster<\/b>. Und wenn wir uns auf einem neuen Datensatz befinden (Else<\/b>-Teil von If Not frm.NewRecord<\/b>), dann wird btnNaechster <\/b>auch deaktiviert.<\/p>\n Diese Schaltfläche wird definitiv deaktiviert, wenn das Recordset nicht aktualisierbar ist. Anderenfalls prüfen wir, ob wir uns bereits auf einem neuen, leeren Datensatz befinden. Falls ja, wird die Schaltfläche ebenfalls deaktiviert, sonst wird sie aktiviert.<\/p>\n Damit haben wir alle Zustände bezüglich der Aktivierung der Schaltflächen geklärt.<\/p>\n Fehlt noch das editBox<\/b>-Element txtAktuellerDatensatz<\/b>: Dieses soll auch nur deaktiviert werden, wenn keine Datensätze vorhanden sind und die Datensatzgruppe nicht aktualisierbar ist. Deshalb fügen wir dieses Element zu dem Case<\/b>-Zweig hinzu, der bereits die Schaltflächen cmdErster <\/b>und cmdLetzter <\/b>behandelt.<\/p>\n Beim Anklicken einer jeden der fünf Schaltflächen wird die Prozedur onAction <\/b>aufgerufen (siehe Listing 3). Diese nimmt mit dem Parameter control <\/b>einen Verweis auf das aufrufende Steuerelement entgegen.<\/p>\n Listing 3: Die Prozedur onAction zum Durchführen von Aktionen beim Anklicken der Schaltflächen<\/span><\/b><\/p>\n Sie referenziert das aktive Formular mit der Variablen frm <\/b>und das darin enthaltene Recordset mit rst<\/b>. Dann unterscheidet sie in einer Select Case<\/b>-Bedingung nach dem Wert der Eigenschaft ID <\/b>des control<\/b>-Elements.<\/p>\n Die Schaltfläche btnErster <\/b>soll den Datensatzzeiger auf den ersten Datensatz des Recordsets verschieben. Dazu ruft die Prozedur die Methode MoveFirst <\/b>des Recordsets auf rst <\/b>auf. Das führt aber zu einem Fehler, wenn die Datensatzgruppe leer ist. Also prüfen wir vorab per rst.BOF<\/b>, ob sich der Datensatzzeiger bereits vor dem ersten Datensatz befindet.<\/p>\n Danach folgt noch ein wichtiger Schritt: Der Aufruf der Methode Invalidate <\/b>der Objektvariablen objRibbon_Navigation<\/b>. Dies führt dazu, dass alle Callbackprozeduren für die Elemente dieser Ribbondefinition erneut aufgerufen werden. Damit rufen nun beispielsweise alle Steuerelemente erneut die getEnabled<\/b>-Prozedur auf, um ihren Aktiviert-Zustand neu einzustellen.<\/p>\n Bei der Schaltfläche btnVorheriger <\/b>sollte man meinen, wir könnten hier einfach den Befehl rst.MovePrevious <\/b>anwenden. Das ist allerdings nicht immer der Fall: Wenn das Formular nämlich einen neuen, leeren Datensatz anzeigt, ist als Position des Datensatzzeigers dennoch der letzte Datensatz gespeichert. Das würde bedeuten, dass wir bei 100 Datensätzen von einem neuen Datensatz auf den neunundneunzigsten Datensatz springen würden statt auf den hundertsten.<\/p>\n Also prüfen wir in diesem Case<\/b>-Zweig mit frm.NewRecord<\/b>, ob das Formular gerade einen neuen, leeren Datensatz anzeigt. Falls nicht, bewegen wir den Datensatzzeiger mit rst.MovePrevious <\/b>zum vorherigen Datensatz, sonst mit rst.MoveLast <\/b>zum letzten Datensatz. Auch hier rufen wir wieder objRibbon_Navigation.Invalidate <\/b>auf, um den Status der Steuerelemente zu aktualisieren.<\/p>\n Hat der Benutzer die Schaltfläche btnNaechster <\/b>angeklickt, müssen wir prüfen, ob sich der Datensatzzeiger gerade auf dem letzten Datensatz befindet. Ist das nicht der Fall, zeigen wir mit rst.MoveNext <\/b>den nächsten Datensatz an.<\/p>\n Befinden wir uns hingegen schon auf dem letzten Datensatz, hat diese Schaltfläche die gleiche Funktion wie die Schaltfläche btnNeu<\/b>. Wir springen dann also mit DoCmd.GotoRecord Record:=acNewRec <\/b>zu einem neuen Datensatz.<\/p>\n Die Schaltfläche btnLetzter <\/b>hat einen klaren Auftrag: Sie soll einfach zum letzten Datensatz springen. Dazu verwenden wir die Methode rst.MoveLast<\/b>. Allerdings kann auch hier ein Fehler auftreten, wenn das Recordset leer ist. Deshalb prüfen wir vorab mit rst.EOF<\/b>, ob sich das Recordset bereits hinter dem letzten Datensatz befindet – ist das der Fall, wird rst.MoveLast <\/b>nicht ausgeführt.<\/p>\n Wie wir zu einem neuen, leeren Datensatz kommen, haben wir oben schon gesehen, und die Schaltfläche btnNeu macht nichts anderes: DoCmd.GotoRecord Record:=acNewRec<\/b>.<\/p>\n Damit wir auf die Eingabe des Benutzers in das editBox<\/b>-Element txtAktuellerDatensatz <\/b>reagieren können, haben wir das Attribut onChange <\/b>mit dem Namen der gleichnamigen Prozedur gefüllt. Diese enthält den vom Benutzer eingegeben Wert mit dem Parameter text <\/b>und prüft, ob der Benutzer einen numerischen Wert eingegeben hat.<\/p>\n Falls ja, weist sie der Variablen rst <\/b>das Recordset des aktuell aktiven Formulars zu. Enthält der Parameter einen Zahlenwert, der kleiner ist als die enthaltene Anzahl Datensätze, wird die Position des Datensatzzeigers über die Eigenschaft AbsolutePosition<\/b> des Recordsets auf die gewünschte Position eingestellt. Dabei wird der eingegebene Wert noch um 1 <\/b>nach unten korrigiert, da AbsolutePosition <\/b>den Index mit 0 <\/b>beginnend erwartet.<\/p>\n Die Prozedur sorgt schließlich noch durch den Aufruf der Invalidate<\/b>-Methode für die Aktualisierung der übrigen Steuerelemente:<\/p>\n Eine Frage, die wir noch bearbeiten müssen, ist die nach der Anzeige der Ribbonanpassung. Bisher wird das dort definierte tab<\/b>-Element neben all den anderen Elementen angezeigt. Wir wollen dieses aber direkt sehen können. Die einfachste Möglichkeit dazu ist, für das ribbon<\/b>-Element das Attribut startFromScratch <\/b>auf true <\/b>einzustellen:<\/p>\n Das sorgt dafür, dass wie in Bild 5 alle übrigen eingebauten Elemente ausgeblendet werden und unsere Anpassung direkt sichtbar ist.<\/p>\n Bild 5: Die Ribbonanpassung blendet alle anderen Elemente aus.<\/span><\/b><\/p>\n Da wir nun eigene Navigationsschaltflächen anzeigen, können wir die eingebauten Elemente ausblenden. Dazu stellen wir die Eigenschaft Navigationsschaltflächen <\/b>des Formulars einfach auf Nein <\/b>ein.<\/p>\n Das Problem ist: Solange der Benutzer ausschließlich mit den Navigationsschaltflächen im Ribbon navigiert, sind die dortigen Schaltflächen entsprechend der Position des Datensatzzeigers im Formular aktiviert oder deaktiviert.<\/p>\n Wenn der Benutzer jedoch beispielsweise in der Datenblattansicht mit der Nach unten<\/b>-Taste zu den folgenden Datensätzen navigiert, synchronisiert sich das Ribbon nicht automatisch. Wir müssen dem Formular also noch ein paar Ereignisprozeduren verpassen, damit das Ribbon regelmäßig aktualisiert wird.<\/p>\n Das offensichtlichste Ereignis, das wir berücksichtigen müssen, ist das Ereignis Beim Anzeigen<\/b>. Dieses wird beim Anzeigen eines jeden Datensatzes ausgelöst, also nicht nur beim Anzeigen des ersten Datensatzes nach dem Öffnen des Formulars, sondern auch bei jedem Datensatzwechsel.<\/p>\n Für diese Ereigniseigenschaft hinterlegen wir daher die folgende Ereignisprozedur:<\/p>\n Damit können wir mit den Nach oben<\/b>– und Nach unten<\/b>-Tasten durch die Datensätze navigieren und das Navigationsribbon wird immer auf dem aktuellen Stand gehalten.<\/p>\n Ein Sonderfall tritt ein, wenn wir einen neuen Datensatz anlegen und diesen beispielsweise mit Strg + S <\/b>speichern (oder durch einen Klick auf den Datensatzmarkierer).<\/p>\n Dann wird der neue Datensatz zum letzten Datensatz und darunter wird der nächste neue, leere Datensatz angezeigt. Allerdings lösen wir so nicht das Ereignis Beim Anzeigen <\/b>aus und somit wird das Navigationsribbon nicht aktualisiert.<\/p>\n In diesem Fall behelfen wir uns mit der Ereignisprozedur Nach Aktualisierung<\/b>:<\/p>\n Wenn wir den aktuellen Datensatz löschen, erhalten wir einen Fehler in der Prozedur getEnabled<\/b> für die Schaltfläche btnVorheriger<\/b>, weil wir <\/p>\n\n
Verhalten der Navigationssteuerelemente untersuchen<\/h2>\n
Sonderfall nicht aktualisierbare Datensatzquelle<\/h2>\n
Aussehen des Ribbons definieren<\/h2>\n
![\"So](\"..\/fileadmin\/_temp_\/2023_01\/pic_1415_002.png\")
<\/p>\n\n
![\"Tabelle](\"..\/fileadmin\/_temp_\/2023_01\/pic_1415_003.png\")
<\/p>\n<?xml version=\"1.0\"?>\r\n<customUI xmlns=\"http:\/\/schemas.microsoft.com\/office\/2009\/07\/customui\" onLoad=\"OnLoad_Navigation\" loadImage=\"loadImage\">\r\n <ribbon>\r\n <tabs>\r\n <tab id=\"tabNavigation\" getLabel=\"getLabel\">\r\n <group id=\"grpNavigation\" label=\"Datensatznavigation\">\r\n <button image=\"navigate_beginning\" getEnabled=\"getEnabled\" label=\"Erster Datensatz\" \r\n id=\"btnErster\" onAction=\"onAction\" size=\"large\"\/>\r\n <button image=\"navigate_left\" getEnabled=\"getEnabled\" label=\"Vorheriger Datensatz\" \r\n id=\"btnVorheriger\" onAction=\"onAction\" size=\"large\"\/>\r\n <editBox label=\"Aktueller Datensatz\" id=\"txtAktuellerDatensatz\" getText=\"getText\" \r\n onChange=\"onChange\" sizeString=\"100 von 100\" getEnabled=\"getEnabled\"\/>\r\n <button image=\"navigate_right\" getEnabled=\"getEnabled\" label=\"Nächster Datensatz\" \r\n id=\"btnNaechster\" onAction=\"onAction\" size=\"large\"\/>\r\n <button image=\"navigate_end\" getEnabled=\"getEnabled\" label=\"Letzter Datensatz\" \r\n id=\"btnLetzter\" onAction=\"onAction\" size=\"large\"\/>\r\n <button image=\"add\" getEnabled=\"getEnabled\" label=\"Neuer Datensatz\" id=\"btnNeu\" \r\n onAction=\"onAction\" size=\"large\"\/>\r\n <\/group>\r\n <\/tab>\r\n <\/tabs>\r\n <\/ribbon>\r\n<\/customUI><\/pre>\n
Vorbereitung zum Aktualisieren der Ribbonelemente<\/h2>\n
Public <\/span>objRibbon_Navigation As <\/span>IRibbonUI<\/pre>\nSub <\/span>onLoad_Navigation(ribbon As <\/span>IRibbonUI)\r\n Set<\/span> objRibbon_Navigation = ribbon\r\nEnd Sub<\/span><\/pre>\ntab-Beschriftung ermitteln<\/h2>\n
Sub <\/span>getLabel(control As <\/span>IRibbonControl, ByRef label)\r\n Dim <\/span>frm As <\/span>Form\r\n Select Case control.ID\r\n Case <\/span>\"tabNavigation\"\r\n Set<\/span> frm = Screen.ActiveForm\r\n If <\/span>Len<\/span>(frm.Caption) = 0 Then<\/span>\r\n label = frm.Name\r\n Else<\/span>\r\n label = frm.Caption\r\n End If<\/span>\r\n End Select<\/span>\r\nEnd Sub<\/span><\/pre>\nGruppe mit Steuerelementen<\/h2>\n
\n
Anzeige der Datensatzzeigerposition<\/h2>\n
\n
Bilder bereitstellen<\/h2>\n
![\"Tabelle](\"..\/fileadmin\/_temp_\/2023_01\/pic_1415_004.png\")
<\/p>\nDoCmd.OpenTable \"MSysResources\"<\/pre>\n
DoCmd.OpenTable \"USysRibbons\"<\/pre>\n
Text für die Anzeige der Position des Datensatzzeigers anzeigen<\/h2>\n
Sub <\/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 = Screen.ActiveForm\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 & \"\/\" _\r\n & rst.RecordCount\r\n Else<\/span>\r\n text = rst.RecordCount + 1 & \"\/\" _\r\n & rst.RecordCount + 1\r\n End If<\/span>\r\n End If<\/span>\r\nEnd Sub<\/span><\/pre>\nAktivieren und Deaktivieren der Schaltflächen<\/h2>\n
Sub <\/span>getEnabled(control As <\/span>IRibbonControl, ByRef enabled)\r\n Dim <\/span>frm As <\/span>Form\r\n Dim <\/span>rst As <\/span>DAO.Recordset\r\n Set<\/span> frm = Screen.ActiveForm\r\n Set<\/span> rst = frm.Recordset\r\n Select Case control.ID\r\n Case <\/span>\"btnErster\", \"btnLetzter\", \"txtAktuellerDatensatz\"\r\n If <\/span>rst.RecordCount = 0 And rst.Updatable = False<\/span> Then<\/span>\r\n enabled = False<\/span>\r\n Else<\/span>\r\n enabled = True<\/span>\r\n End If<\/span>\r\n Case <\/span>\"btnVorheriger\"\r\n If <\/span>rst.AbsolutePosition = 0 Or rst.AbsolutePosition = -1 Then<\/span>\r\n enabled = False<\/span>\r\n Else<\/span>\r\n enabled = True<\/span>\r\n End If<\/span>\r\n Case <\/span>\"btnNaechster\"\r\n If <\/span>Not<\/span> frm.NewRecord Then<\/span>\r\n If <\/span>rst.AbsolutePosition = rst.RecordCount - 1 Then<\/span>\r\n If <\/span>rst.Updatable Then<\/span>\r\n enabled = True<\/span>\r\n Else<\/span>\r\n enabled = False<\/span>\r\n End If<\/span>\r\n Else<\/span>\r\n enabled = True<\/span>\r\n End If<\/span>\r\n Else<\/span>\r\n enabled = False<\/span>\r\n End If<\/span>\r\n Case <\/span>\"btnNeu\"\r\n If <\/span>rst.Updatable Then<\/span>\r\n If <\/span>Not<\/span> frm.NewRecord Then<\/span>\r\n enabled = True<\/span>\r\n Else<\/span>\r\n enabled = False<\/span>\r\n End If<\/span>\r\n Else<\/span>\r\n enabled = False<\/span>\r\n End If<\/span>\r\n End Select<\/span>\r\nEnd Sub<\/span><\/pre>\nAktivieren der Schaltflächen für die Anzeige des ersten oder letzten Datensatzes<\/h2>\n
Aktivieren der Schaltfläche für die Anzeige des vorherigen Datensatzes<\/h2>\n
Aktivieren der Schaltfläche für die Anzeige des nächsten Datensatzes<\/h2>\n
Aktivieren der Schaltfläche zum Anlegen eines neuen, leeren Datensatzes<\/h2>\n
Anklicken der Schaltflächen<\/h2>\n
Sub <\/span>onAction(control As <\/span>IRibbonControl)\r\n Dim <\/span>frm As <\/span>Form\r\n Dim <\/span>rst As <\/span>DAO.Recordset\r\n Set<\/span> frm = Screen.ActiveForm\r\n Set<\/span> rst = frm.Recordset\r\n Select Case control.ID\r\n Case <\/span>\"btnErster\"\r\n If <\/span>Not<\/span> rst.BOF Then<\/span>\r\n rst.MoveFirst\r\n End If<\/span>\r\n objRibbon_Navigation.Invalidate\r\n Case <\/span>\"btnVorheriger\"\r\n If <\/span>Not<\/span> frm.NewRecord Then<\/span>\r\n rst.MovePrevious\r\n Else<\/span>\r\n rst.MoveLast\r\n End If<\/span>\r\n objRibbon_Navigation.Invalidate\r\n Case <\/span>\"btnNaechster\"\r\n If <\/span>Not<\/span> rst.AbsolutePosition = rst.RecordCount - 1 Then<\/span>\r\n rst.MoveNext<\/span>\r\n Else<\/span>\r\n DoCmd.GoToRecord record:=acNewRec\r\n End If<\/span>\r\n objRibbon_Navigation.Invalidate\r\n Case <\/span>\"btnLetzter\"\r\n If <\/span>Not<\/span> rst.EOF Then<\/span>\r\n rst.MoveLast\r\n End If<\/span>\r\n objRibbon_Navigation.Invalidate\r\n Case <\/span>\"btnNeu\"\r\n DoCmd.GoToRecord record:=acNewRec\r\n objRibbon_Navigation.Invalidate\r\n End Select<\/span>\r\nEnd Sub<\/span><\/pre>\nZum ersten Datensatz<\/h2>\n
Zum vorherigen Datensatz<\/h2>\n
Zum nächsten Datensatz<\/h2>\n
Zum letzten Datensatz <\/h2>\n
Zu einem neuen, leeren Datensatz<\/h2>\n
Eingabe der anzuzeigenden Datensatzposition per Textfeld<\/h2>\n
Sub <\/span>onChange(control As <\/span>IRibbonControl, text As String<\/span>)\r\n Dim <\/span>rst As <\/span>DAO.Recordset\r\n If <\/span>IsNumeric(text) Then<\/span>\r\n Set<\/span> rst = Screen.ActiveForm.Recordset\r\n If <\/span>text <= rst.RecordCount Then<\/span>\r\n rst.AbsolutePosition = text - 1\r\n End If<\/span>\r\n End If<\/span>\r\n objRibbon_Navigation.Invalidate\r\nEnd Sub<\/span><\/pre>\nRibbon direkt anzeigen<\/h2>\n
<ribbon startFromScratch=\"true\"><\/pre>\n
![\"Die](\"..\/fileadmin\/_temp_\/2023_01\/pic_1415_005.png\")
<\/p>\nEingebaute Navigationsschaltflächen ausblenden<\/h2>\n
Problem Synchronisation<\/h2>\n
Private Sub <\/span>Form_Current()\r\n objRibbon_Navigation.Invalidate\r\nEnd Sub<\/span><\/pre>\nAnlegen und Speichern eines neuen Datensatzes<\/h2>\n
Private Sub <\/span>Form_AfterUpdate()\r\n objRibbon_Navigation.Invalidate\r\nEnd Sub<\/span><\/pre>\nLöschen eines Datensatzes<\/h2>\n