<\/p>\n
Formulare sind oft völlig überfrachtet mit Steuerelementen zur Anzeige und Auswahl von Daten und Schaltflächen. Das lässt sich zumindest teilweise ändern, indem Sie einige Elemente aus dem Formular in ein Ribbon auslagern, das dann beim Erscheinen des Formulars eingeblendet wird. Bei einfachen Schaltflächen ist das noch recht einfach, aber sobald die Steuer-elemente etwa abhängig von den angezeigten Daten ein- oder ausgeblendet werden sollen, wird es interessant. In diesem Beitrag schauen wir uns an, wie das gelingt. <\/b><\/p>\n
Konkret nehmen wir uns das Beispiel aus dem Beitrag Datenblatt: Reihenfolge mehrerer Einträge ändern<\/b> (www.access-im-unternehmen.de\/1198<\/b>) vor. Hier finden wir in einem Formular ein Unterformular in der Datenblattansicht vor (siehe Bild 1). Dieses enthält vier Schaltflächen, mit denen Sie die Reihenfolge der Einträge des Datenblatts über die Werte des Feldes ReihenfolgeID <\/b>manipulieren können. Im Falle dieses Beispiels enthält das Datenblatt nicht so viele Felder, dass diese nicht auf das Formular passen würde.<\/p>\n
![\"Ausgangsformular\"](\"..\/fileadmin\/_temp_\/2019_04\/pic_1199_001.png\")
<\/p>\n
Bild 1: Ausgangsformular<\/span><\/b><\/p>\n Wenn dies allerdings der Fall wäre, würde man sich die Schaltflächen an einer anderen Position wünschen. Am Besten, damit diese gar nicht mehr im Weg sind, direkt im Ribbon. Und genau das ist Thema des vorliegenden Artikels: Wir wollen zeigen, wie Sie die Schaltflächen aus einem Formular in das Ribbon übertragen und dabei alle vorgegebenen Funktionen beibehalten.<\/p>\n In unserem Fall betrifft das vor allem das Aktivieren und Deaktivieren der Schaltflächen in Abhängigkeit der angezeigten Daten. Das heißt, dass die Schaltflächen zum Verschieben der Elemente nach oben nur aktiviert sein sollen, wenn die Elemente auch nach oben verschoben werden können. Das gleiche gilt für die Schaltflächen zum Verschieben nach unten – diese sollen nur aktiviert werden, wenn die Elemente auch nach unten verschoben werden können. Außerdem sollen die Schaltflächen natürlich die im Klassenmodul des Formulars gespeicherten Ereignisprozeduren aufrufen.<\/p>\n Eine weitere Anforderung ist, dass das Ribbon nur in Zusammenhang mit der Anzeige dieses Formulars angezeigt werden soll. Um dieses zu öffnen, fügen wir der Anwendung noch ein Start-Ribbon hinzu, das beim Start angezeigt wird und das Öffnen des Formulars frmMehrfachreihenfolgeDatenblatt <\/b>erlaubt. Wir könnten theoretisch auch direkt das Unterformular in der Datenblattansicht öffnen, aber das würde bedeuten, dass wir den kompletten Code des Hauptformulars in das Klassenmodul des Unterformulars übertragen und anpassen müssten. Diesen Schritt wollen wir erst einmal nicht gehen. Daher maximieren wir einfach das Unterformular innerhalb des Hauptformulars und sorgen dafür, dass das Hauptformular mit dem Unterformular beim Anklicken des entsprechenden Ribbon-Eintrags angezeigt wird. Das Ribbon-Tab für das Formular frmMehrfachreihenfolgeDatenblatt<\/b> soll dann rechts neben dem Startribbon erscheinen.<\/p>\n Um das erste Ribbon zu erstellen, fügen wir zunächst eine neue Tabelle namens USysRibbons <\/b>zur Datenbank hinzu. Dieser Tabelle fügen Sie die drei folgenden Felder hinzu (siehe Bild 2):<\/p>\n Bild 2: Entwurf der Tabelle USysRibbons<\/span><\/b><\/p>\n Wenn Sie nicht die Anzeige von Systemobjekten und ausblendeten Objekten deaktiviert haben, verschwindet die Tabelle allerdings direkt nach dem Speichern aus dem Navigationsbereich.<\/p>\n Um diese wieder sichtbar zu machen, klicken Sie mit der rechten Maustaste auf die Titelzeile des Navigationsbereichs und wählen aus dem Kontextmenü den Eintrag Navigationsoptionen… <\/b>aus.<\/p>\n Im nun erscheinenden Dialog Navigationsoptionen <\/b>aktivieren Sie die beiden Optionen Ausgeblendete Objekte anzeigen <\/b>und System-Objekte anzeigen <\/b>(siehe Bild 3). Danach erscheint die Tabelle USysRibbons <\/b>wieder im Navigationsbereich.<\/p>\n Bild 3: Die Navigationsoptionen von Access<\/span><\/b><\/p>\n Danach fügen wir dem Feld RibbonName<\/b> der Tabelle den Wert Main <\/b>und dem Feld RibbonXML <\/b>den XML-Code aus Listing 1 hinzu.<\/p>\n Listing 1: XML-Code für das Start-Ribbon<\/span><\/b><\/p>\n Hier definieren wir die ineinander verschachtelten Elemente customUI<\/b>, ribbon<\/b>, tabs<\/b>, tab<\/b>, group <\/b>und schließlich button<\/b>. Das button<\/b>-Element erhält schließlich über das Attribut imageMso <\/b>den Namen eines eingebauten Icons, eine Beschriftung, eine ID, den Wert large <\/b>für das Attribut size <\/b>und den Wert onAction <\/b>für das Attribut onAction<\/b>. Das bedeutet, dass wir an irgendeiner Stelle – in diesem Fall in einem Standardmodul – eine Prozedur namens onAction<\/b> bereitstellen müssen, die bestimmten syntaktischen Anforderungen genügt. Die Tabelle sieht danach wie in Bild 4 aus.<\/p>\n Bild 4: Ribbon-Definition für das Start-Ribbon<\/span><\/b><\/p>\n Die oben genannte Prozedur onAction <\/b>erstellen wir schließlich so:<\/p>\n Die Prozedur öffnet also dann das gewünschte Formular.<\/p>\n Damit die Benutzeroberfläche Fehler beim Verwenden der benutzerdefinierten Ribbons anzeigt, müssen wir noch eine Access-Option aktivieren. Dazu öffnen Sie über den Eintrag Datei|Optionen <\/b>zunächst den Optionen-Dialog von Access. Hier finden Sie im Bereich Client-ein-stel-lun-gen|Allgemein <\/b>die Option Fehler von Be-nut-zer-ober-flächen-Add-Ins anzeigen<\/b>. Diese aktivieren Sie und schließen den Dialog mit der Schaltfläche OK<\/b> (siehe Bild 5).<\/p>\n Bild 5: Ribbon-Option zum Anzeigen von Ribbon-Fehlern<\/span><\/b><\/p>\n Nun müssen wir nur noch drei Schritte erledigen: <\/p>\n Bild 6: Start-Ribbon für die Anwendung einstellen<\/span><\/b><\/p>\n Nun erscheint das Ribbon wie in Bild 7. Hier klicken Sie auf den Tab namens Beispiele <\/b>und erhalten die Schaltfläche zum Öffnen des Formulars.<\/p>\n Bild 7: Das Start-Ribbon <\/span><\/b><\/p>\n Um die Funktionen der vier Schaltflächen nun über das Ribbon ausführen zu können, legen wir zunächst ein neues Ribbon mit einem eigenen Tab für das Formular frmMehrfachreihenfolgeDatenblatt <\/b>an.<\/p>\n Der XML-Code für dieses Ribbon sieht zunächst wie in Listing 2 aus und bildet das Grundgerüst, das wir gleich noch ausbauen. Erstmal möchten wir überhaupt ein Ribbon mit dem Formular einblenden. Diesen XML-Code fügen Sie in einem zweiten Datensatz in die Tabelle USysRibbons <\/b>ein, und zwar mit dem Eintrag Reihenfolge <\/b>im Feld RibbonName<\/b>.<\/p>\n Listing 2: XML-Code für das Ribbon zum Formular<\/span><\/b><\/p>\n Damit dies gelingt, stellen wir die Eigenschaft Name des Menü-bands <\/b>des Hauptformulars auf den Namen des neu erstellten Ribbons ein – allerdings erst, nachdem wir nach dem Einfügen des neuen Eintrags zur Tabelle USysRibbons <\/b>die Anwendung geschlossen und wieder geöffnet haben (siehe Bild 8). Nur dadurch werden neu hinzugefügte Ribbon-Namen auch in den Auswahlfeldern der jeweiligen Eigenschaften sichtbar.<\/p>\n Bild 8: Menüband festlegen <\/span><\/b><\/p>\n Wenn wir das Formular nun über den Ribbon-Befehl des Start-Ribbons öffnen, erscheint zwar das Formular, aber das Tab<\/b>-Element aus dem zugeordneten Ribbon wird nicht angezeigt (siehe Bild 9). Warum das Ganz einfach: Die Schaltflächen sind zu Beginn deaktiviert, damit bleibt das Unterformular das einzige Steuer-element, das den Fokus erhalten kann. Und das Unterformular hat genau wie das Formular eine eigene Eigenschaft namens Name des Menübands<\/b>. Wir haben nun zwei Möglichkeiten:<\/p>\n Bild 9: Kein neues Ribbon für das Formular<\/span><\/b><\/p>\n Wir entscheiden uns für die zweite Variante, da wir dann gegebenenfalls nur das Ribbon für das Hauptformular ändern müssen:<\/p>\n Damit erhalten wir nun beim Öffnen des Formulars frmMehrfachreihenfolgeDatenblatt<\/b> zwar das neue Ribbon-Tab, allerdings wird dieses nicht aktiviert (siehe Bild 10).<\/p>\n Bild 10: Das Reihenfolge-Ribbon wird nicht aktiviert.<\/span><\/b><\/p>\n Dazu gibt es wiederum drei Möglichkeiten:<\/p>\n Wir schauen uns alle drei Varianten an.<\/p>\n Für diesen Fall benötigen wir zunächst einen Verweis auf die Bibliothek Microsoft Office 14.0 Object Library<\/b>, wobei wir diesen über den Verweise<\/b>-Dialog hinzufügen.<\/p>\n Diesen öffnen Sie über den VBA-Editor mit dem Menübefehl Extras|Verweise<\/b>. Dort fügen Sie dann den genannten Eintrag hinzu (siehe Bild 11).<\/p>\n Bild 11: Verweis auf die Office-Bibliothek<\/span><\/b><\/p>\n Nun fügen wir dem Ribbon-Element customUI <\/b>das Attribut onLoad <\/b>hinzu:<\/p>\n Die hier angegebene Ereignisprozedur onLoad_Reihenfolge <\/b>hinterlegen wir wieder im Modul mdlRibbons<\/b>. Die Prozedur weist lediglich der Variablen objRibbon_Reihenfolge <\/b>einen Verweis auf das per Parameter mitgelieferte Objekt IRibbonUI <\/b>zu:<\/p>\n <\/p>\n Diese Variable müssen wir nun noch deklarieren, was wir im gleichen Modul erledigen:<\/p>\n Nun bietet dieses Objekt verschiedene Methoden an, darunter auch die ActivateTab<\/b>-Methode, die den Namen des zu aktivierenden Tab<\/b>-Elements entgegennimmt. Wann und wie aber wollen wir diese Methode aufrufen Eigentlich sollte dies gleich beim Öffnen des Formulars geschehen, also etwa in der Ereignisprozedur für eine der Ereigniseigenschaften Beim Öffnen <\/b>oder Beim Laden<\/b>.<\/p>\n Wenn wir aber etwa für die Ereignisprozedur Form_Load <\/b>die folgende Anweisung anlegen, gelingt das nicht:<\/p>\n Wir erhalten dann nämlich die Fehlermeldung aus Bild 12, der dadurch ausgelöst wird, dass die Objektvariable noch nicht mit dem Verweis auf das customUI<\/b>-Objekte gefüllt wurde. Das versuchen wir zu umgehen, indem wir das Aktivieren des Tab<\/b>-Elements ein wenig verzögern. Dazu stellen wir die Eigenschaft Zeitgeberintervall <\/b>des Hauptformulars auf den Wert 500 <\/b>ein (für 500 Millisekunden) und für die Ereigniseigenschaft Bei Zeitgeber <\/b>hinterlegen wir die folgende Ereignisprozedur:<\/p>\n Bild 12: Fehler beim Versuch, die ActiveTab-Methode zu nutzen<\/span><\/b><\/p>\n Allerdings erhalten wir hier den gleichen Fehler. Woran liegt das Wir könnten annehmen, dass die Prozedur onLoad_Reihenfolge<\/b> erst ausgeführt wird, wenn das Ribbon-Tab aus dieser Ribbon-Definition angezeigt wird. Allerdings scheint auch dies nicht der Fall zu sein. Wir können ja zwischendurch immer prüfen, ob objRibbon_Reihenfolge <\/b>einen Wert hat – und zwar mit der folgenden VBA-Anweisung, abgesetzt im Direktbereich des VBA-Editors:<\/p>\n Dies liefert aber aktuell immer den Wert True<\/b>, objRibbon_Reihenfolge <\/b>ist also leer. Die Lösung für dieses Problem war: Wir haben das Formular mehrfach aufgerufen und bereits zuvor dafür gesorgt, dass On_Load <\/b>aufgerufen wurde. Damit war objRibbon_Reihenfolge <\/b>gefüllt. Allerdings haben wir anschließend vermutlich durch einen Laufzeitfehler dafür gesorgt, dass die Variable wieder geleert wurde. Da On_Load <\/b>aber bereits ausgeführt war, wurde sie nicht erneut gefüllt … Es gilt also zu beachten: Entweder Sie verhindern Laufzeitfehler durch entsprechend stabile Programmierung mit Fehlerbehandlungen, oder Sie müssen zwischendurch die Anwendung einmal neu laden, damit alle Ribbons et cetera wieder korrekt geladen werden können.<\/p>\n Nach einem Neustart der Anwendung erhalten wir jedoch das gewünschte Ribbon (siehe Bild 13).<\/p>\n Bild 13: Das Formular mit den gewünschten Ribbon-Schaltflächen<\/span><\/b><\/p>\n Noch eine Optimierung ist es, die Eigenschaft Zeitgeberintervall <\/b>gar nicht erst über das Eigenschaftenblatt festzulegen, sondern den Wert per VBA in der Ereignisprozedur Beim Laden<\/b> für die Eigenschaft TimerInterval <\/b>festzulegen:<\/p>\n Anderenfalls kann es während der Entwicklung passieren, dass TimerInterval <\/b>per Code auf 0 <\/b>eingestellt wird und andere Änderungen das Speichern des Formulars erfordern. Dann speichert Access auch den neuen Wert für TimerInterval<\/b>, was dazu führt, dass das Bei Zeitgeber<\/b>-Ereignis beim nächsten Öffnen des Formulars nicht mehr aufgerufen wird.<\/p>\n Dieser Ansatz ist also eher umständlich. Also schauen wir uns die zweite Idee an. Dazu kopieren wir das Haupt- und das Unterformular und hängen jeweils das Suffix Context <\/b>hinten an den Objektnamen an. Die Eigenschaft Herkunftsobjekt <\/b>des Formulars frmMehrfachreihenfolgeDatenblattContext <\/b>stellen wir dann entsprechend auf sfmMehrfachreihenfolgeDatenblattContext <\/b>ein.<\/p>\n Dann legen wir einen weiteren Datensatz in der Tabelle USysRibbons <\/b>an, diesmal mit dem Wert ReihenfolgeKontext <\/b>im Feld RibbonName <\/b>und mit dem Code aus Listing 3 im Feld RibbonXML<\/b>. Neu ist in dieser Version, dass wir unterhalb des Ribbon-Elements nicht das tabs<\/b>-, sondern das contextualTabs<\/b>-Element einfügen. Dieses nimmt dann ein tabSet<\/b>-Element auf mit dem Wert TabSetFormReportExtensibility <\/b>für das Attribut idMso<\/b>. Das ist wichtig, sonst funktioniert der kontextuelle Tab nicht.<\/p>\n Listing 3: XML-Code für das Ribbon zum Formular mit contextualTabs<\/span><\/b><\/p>\n Darunter finden wir dann wieder ein herkömmliches tab<\/b>-Element, dass die gleichen Steuer-elemente enthält wie das aus dem vorherigen Beispiel. Nachdem Sie diesen Datensatz zur Tabelle USysRibbons <\/b>hinzugefügt haben, können Sie die Anwendung schließen und neu starten und danach den Namen des neuen Ribbons in der Eigenschaft Name des Menübands <\/b>eintragen. Für das neue Formular fügen wir ein neues Element zum Start-Ribbon hinzu:<\/p>\n Da wir nun zwei Schaltflächen haben, welche die Prozedur onAction <\/b>aufrufen, müssen wir dort eine Unterscheidung nach dem Namen der auslösenden Schaltfläche vornehmen:<\/p>\n Wenn wir das Formular nun öffnen, erscheint direkt auch das kontextuelle tab<\/b>-Element namens Reihenfolge <\/b>(siehe Bild 14).<\/p>\n Bild 14: Das kontextuelle tab-Element wird automatisch mit dem Formular aktiviert.<\/span><\/b><\/p>\n Allerdings haben wir die Feststellung gemacht, dass nach dem Schließen und erneutem Öffnen des Formulars über das Start-Ribbon nicht mehr automatisch das Formular-Tab aktiviert wird. Also ist möglicherweise doch die erste Variante die sicherere – auch wenn sie etwa mehr Aufwand erfordert. Für die folgenden Schritte arbeiten wir daher mit dem Formular frmMehrfachreihenfolgeDatenblatt <\/b>und dem entsprechenden Unterformular weiter.<\/p>\n Die dritte Möglichkeit, die am zuverlässigsten arbeiten dürfte, ist das Einstellen des Attributs startFromScratch <\/b>des ribbon<\/b>-Elements auf den Wert true<\/b>. Damit zeigt Access dann nur noch die in der aktuellen Ribbon-Definition festgelegten Elemente an – mit Ausnahme einiger eingebauter Elemente im Datei<\/b>-Bereich. Der Nachteil hier: Sie können dann auch nur auf Elemente des Ribbons zugreifen, die mit dem aktuellen Formular eingeblendet werden.<\/p>\n Nun kümmern wir uns um das Unterformular-Steuerelement, das wir auf die Größe des Hauptformulars vergrößern – wir lassen lediglich einen kleinen Streifen für die Schaltflächen, die wir zur Kontrolle noch im Formular lassen. Außerdem stellen wir die Eigenschaften Horizontaler Anker <\/b>und Vertikaler Anker <\/b>jeweils auf den Wert Beide <\/b>ein.<\/p>\n Damit füllt das Datenblatt beim Maximieren annähernd den kompletten Platz im Access-Fenster aus.<\/p>\n Als Erstes wollen wir nun die bisher über die Schaltflächen des Formulars gesteuerten Ereignisprozeduren über die Schaltflächen des Ribbons auslösen. Müssen wir dazu die Inhalte der Ereignisprozeduren in die Prozedur onAction <\/b>übertragen oder diese gegebenenfalls in Prozeduren ausgliedern, die dann von onAction <\/b>aus aufgerufen werden<\/p>\n Nein, das ist nicht nötig, aber ein paar Änderungen müssen wir schon vornehmen. Die erste ist, dass wir die Ereignisprozedur in eine öffentliche Funktion umwandeln, die dann so aussieht:<\/p>\n Da Sie den Typ der Prozedur nun geändert haben, kann Access beim Öffnen des Formulars allerdings nicht mehr die ursprüngliche Sub<\/b>-Prozedur finden. Jedoch ist in der Ereigniseigenschaft Beim Klicken <\/b>der Schaltfläche cmdTop <\/b>noch immer der Wert [Ereignisprozedur] <\/b>eingetragen. Diesen Wert müssen Sie dort entfernen, damit das Formular einwandfrei funktioniert (siehe Bild 15).<\/p>\n Bild 15: Diese Eigenschaft muss geleert werden.<\/span><\/b><\/p>\n Und später haben wir dann festgestellt, dass es auch mit Namen von Prozeduren, die eigentlich für die Ereignisprozeduren vorgesehen sind, Probleme geben kann. Also benennen wir die Function<\/b>-Prozedur gleich in btnTop_Click <\/b>um. btn <\/b>ist das Präfix für die button<\/b>-Elemente im Ribbon, cmd <\/b>das für die CommandButton<\/b>-Steuerelemente unter Access:<\/p>\n Die von Sub<\/b> in Function <\/b>geänderte Prozedur können wir dann über das Attribut onAction <\/b>des jeweiligen button<\/b>-Elements der Ribbon-Definition angeben. Allerdings dürfen wir in diesem Fall nicht einfach nur den Funktionsnamen angeben, sondern müssen noch ein Gleichheitszeichen voranstellen und ein Klammernpaar hinten anfügen, also =btnTop_Click()<\/b>:<\/p>\n Nach dem Markieren eines Datensatzes im Formular frmMehrfachreihenfolgeDatenblatt<\/b> und dem Anklicken der Ribbon-Schaltfläche btnTop <\/b>erhalten wir allerdings die Fehlermeldung aus Bild 16. Da der Fehler durch eine per Ribbon-Schaltfläche aufgerufene Prozedur ausgelöst wurde, greift die herkömmliche Fehlerbehandlung nicht. Also müssen wir uns per Debugging zur fehlerhaften Zeile durchhangeln.<\/p>\n Bild 16: Fehlermeldung beim Aufruf per Ribbon<\/span><\/b><\/p>\n Ohne ins Detail gehen zu wollen: Der Fehler wurde ausgelöst, weil die Ereignisprozedur Beim Verlassen <\/b>des Unterformular-Steuerelements nicht aufgerufen und dadurch ein Array nicht gefüllt wurde.<\/p>\n Die wichtige Information hieraus ist: Wenn ein Unterformular den Fokus hat und Sie betätigen ein anderes Steuer-element im Hauptformular, verliert das Unterformular den Fokus und das Ereignis Beim Verlassen <\/b>wird ausgelöst. Wenn Sie hingegen bei aktiviertem Unterformular einen Ribbon-Befehl betätigen, behält das Unterformular den Fokus. Das ist insofern wichtig, weil Beim Verlassen <\/b>in diesem Fall nicht ausgelöst wird. Wenn wie hier Daten für die gewünschte Aktion in dieser Ereignisprozedur vorbereitet werden, müssen Sie einen anderen Weg dazu finden. In diesem Fall können wir den Aufruf der Ereignisprozedur sfm_Exit <\/b>allerdings einfach vorn in die durch den Ribbon-Befehl aufgerufene Funktion eintragen:<\/p>\n Vorher haben wir dazu das Ereignis Beim Verlassen <\/b>des Unterformular-Steuerelements genutzt, weil wir nur zu diesem Zeitpunkt noch auf die Markierung der Datensätze im Unterformular zugreifen konnten. Wenn die Schaltfläche cmdTop <\/b>erst den Fokus hatte, waren die Datensätze im Unterformular bereits nicht mehr markiert.<\/p>\n Damit können wir nun auch den ersten Eintrag im Datenblatt markieren und diesen mit einem Klick auf die Ribbon-Schaltfläche btnTop <\/b>an die erste Position verschieben.<\/p>\n Auf die gleiche Weise gestalten wir nun die übrigen Ereignisprozeduren cmdUp_Click<\/b>, cmdDown_Click <\/b>und cmdBottom_Click <\/b>um:<\/p>\n Damit haben wie die Funktionen der Schaltflächen des Formulars bereits auf die im Ribbon übertragen. Jetzt kommt der spannende Teil – das Aktivieren und Deaktivieren der Schaltflächen in Abhängigkeit der markierten Einträge.<\/p>\n Wie wir wissen, gibt es keine direkt zugreifbaren Eigenschaften für Ribbons – genau, wie es keine Ereignisse gibt. Allerdings gibt es die Callback-Attribute. Das sind die Attribute, deren Name mit get… <\/b>beginnt. Darunter befindet sich auch eines namens getEnabled<\/b>. Dieses wollen wir nun nutzen, um die Schaltflächen in Abhängigkeit der markierten Datensätze im Unterformular zu aktivieren oder zu deaktivieren.<\/p>\n Dazu benötigen wir in jedem Fall die Objektvariable, die wir weiter oben unter Ribbon-Tab per VBA-Code aktivieren <\/b>deklariert und gefüllt haben:<\/p>\n Dann fügen wir jeweils das Attribut getEnabled <\/b>mit dem Wert getEnabled <\/b>zu den vier button<\/b>-Elementen hinzu:<\/p>\n Beim ersten Ausprobieren des geänderten Ribbons nach Schließen und Öffnen der Anwendung erhalten wir vier Mal die Fehlermeldung aus Bild 17. Wir müssen also erst zumindest eine leere Prozedur dieses Namens anlegen. Diese sieht wie folgt aus und landet im Modul mdlRibbons<\/b>:<\/p>\n Bild 17: Die Prozedur getEnabled fehlt noch.<\/span><\/b><\/p>\n Wenn wir die Anwendung nun schließen und erneut laden und dann das Formular frmMehrfachreihenfolgeDatenblatt <\/b>öffnen, erscheint das Ribbon wie in Bild 18.<\/p>\n Bild 18: Die button-Elemente sind deaktiviert.<\/span><\/b><\/p>\n Die vier button<\/b>-Elemente sind deaktiviert, was logisch ist: Wir haben für alle das Attribut getEnabled <\/b>auf die Callback-Funktion getEnabled <\/b>eingestellt und diese gibt den Standardwert False <\/b>für den zweiten Parameter enabled <\/b>zurück. Nun müssen wir diese Prozedur noch so ausstatten, dass sie je nach den markierten Datensätzen entsprechende Werte für enabled <\/b>zurückliefert. Leider ist es nicht möglich, diese Callback-Prozedur direkt im Klassenmodul des Formulars unterzubringen. Sie muss in einem Standardmodul verfügbar sein.<\/p>\n Hier müssten wir die Prozedur ActivateControls<\/b>, die bisher das Aktivieren und Deaktivieren der Steuer-elemente im Formular übernommen hat, in die Prozedur getEnabled <\/b>übertragen und umprogrammieren.<\/p>\n Da diese jedoch viele Referenzen zum Unterformular hat, ändern wir den Plan: Wir speichern die Zustände der Schaltflächen einfach in Boolean<\/b>-Variablen und stellen in getEnabled <\/b>den enabled<\/b>-Parameter je nach Fall auf den entsprechenden Boolean<\/b>-Wert ein. Die Boolean<\/b>-Variablen deklarieren wir wie folgt:<\/p>\n In der Prozedur getEnabled <\/b>unterscheiden wir dann wieder in einer Select Case<\/b>-Bedingung nach dem Namen des auslösenden Steuerelements des Ribbons.<\/p>\n Je nach Element weisen wir dann den Wert der entsprechenden Boolean<\/b>-Variablen zu:<\/p>\n Schließlich kommen wir zur Anpassung der Prozedur ActivateControls, die von verschiedenen Stellen bei der Aktualisierung der Markierung der Datensätze aufgerufen wird:<\/p>\n Hier ersetzen wir zunächst die Zuweisung, die zuvor direkt an die Enabled<\/b>-Eigenschaft der Formularschaltflächen ging, durch das Einstellen der vier Boolean<\/b>-Variablen auf den Wert Start-Ribbon erstellen<\/h2>\n
![\"Entwurf](\"..\/fileadmin\/_temp_\/2019_04\/pic_1199_003.png\")
<\/p>\n\n
USysRibbons wieder einblenden<\/h2>\n
![\"Die](\"..\/fileadmin\/_temp_\/2019_04\/pic_1199_002.png\")
<\/p>\nRibbon-Definition für das Start-Ribbon<\/h2>\n
<xml version=\"1.0\">\r\n<customUI xmlns=\"http:\/\/schemas.microsoft.com\/office\/2009\/07\/customui\">\r\n <ribbon>\r\n <tabs>\r\n <tab id=\"tabBeispiele\" label=\"Beispiele\">\r\n <group id=\"grpFormulare\" label=\"Formulare\">\r\n <button imageMso=\"AccessFormDatasheet\" label=\"Mehrfachreihenfolge \r\n Datenblatt\" id=\"btnMehrfachreihenfolgeDatenblatt\" onAction=\"onAction\" \r\n size=\"large\"\/>\r\n <\/group>\r\n <\/tab>\r\n <\/tabs>\r\n <\/ribbon>\r\n<\/customUI><\/pre>\n
![\"Ribbon-Definition](\"..\/fileadmin\/_temp_\/2019_04\/pic_1199_004.png\")
<\/p>\nCode für die Schaltfläche zum Öffnen des Formulars<\/h2>\n
Sub <\/span>onAction(control As <\/span>IRibbonControl)\r\n DoCmd.OpenForm \"frmMehrfachreihenfolgeDatenblatt\"\r\nEnd Sub<\/span><\/pre>\nRibbonfehler anzeigen<\/h2>\n
![\"Ribbon-Option](\"..\/fileadmin\/_temp_\/2019_04\/pic_1199_005.png\")
<\/p>\nAbschließende Schritte<\/h2>\n
\n
![\"Start-Ribbon](\"..\/fileadmin\/_temp_\/2019_04\/pic_1199_006.png\")
<\/p>\n![\"Das](\"..\/fileadmin\/_temp_\/2019_04\/pic_1199_007.png\")
<\/p>\nSchaltflächen ins Ribbon<\/h2>\n
<xml version=\"1.0\">\r\n<customUI xmlns=\"http:\/\/schemas.microsoft.com\/office\/2009\/07\/customui\">\r\n <ribbon>\r\n <tabs>\r\n <tab id=\"tabReihenfolge\" label=\"Reihenfolge\">\r\n <group id=\"grpReihenfolgeAendern\" label=\"Reihenfolge ändern\">\r\n <button imageMso=\"ShapeUpArrow\" label=\"Ganz nach oben\" id=\"btnTop\" size=\"large\"\/>\r\n <button id=\"btnUp\" imageMso=\"ShapeUpArrow\" label=\"Nach oben\" size=\"large\"\/>\r\n <button id=\"btnDown\" imageMso=\"ShapeDownArrow\" label=\"Nach unten\" size=\"large\"\/>\r\n <button id=\"btnBottom\" imageMso=\"ShapeDownArrow\" label=\"Ganz nach unten\" size=\"large\"\/>\r\n <\/group>\r\n <\/tab>\r\n <\/tabs>\r\n <\/ribbon>\r\n<\/customUI><\/pre>\n
![\"Menüband](\"..\/fileadmin\/_temp_\/2019_04\/pic_1199_008.png\")
<\/p>\nRibbon für das Unterformular<\/h2>\n
![\"Kein](\"..\/fileadmin\/_temp_\/2019_04\/pic_1199_009.png\")
<\/p>\n\n
Private Sub <\/span>Form_Load()\r\n Me!sfm.Form.RibbonName = Me.RibbonName\r\nEnd Sub<\/span><\/pre>\n![\"Das](\"..\/fileadmin\/_temp_\/2019_04\/pic_1199_010.png\")
<\/p>\n\n
Ribbon-Tab per VBA-Code aktivieren<\/h2>\n
![\"Verweis](\"..\/fileadmin\/_temp_\/2019_04\/pic_1199_011.png\")
<\/p>\n<customUI xmlns=\"http:\/\/schemas.microsoft.com\/office\/2009\/07\/customui\" onLoad=\"onLoad_Reihenfolge\"><\/pre>\n
Sub <\/span>onLoad_Reihenfolge(ribbon As <\/span>IRibbonUI)\r\n Set<\/span> objRibbon_Reihenfolge = ribbon\r\nEnd Sub<\/span><\/pre>\nPublic <\/span>objRibbon_Reihenfolge As <\/span>IRibbonUI<\/pre>\nPrivate Sub <\/span>Form_Load()\r\n objRibbon_Reihenfolge.ActivateTab \"tabReihenfolge\"\r\nEnd Sub<\/span><\/pre>\n![\"Fehler](\"..\/fileadmin\/_temp_\/2019_04\/pic_1199_012.png\")
<\/p>\nPrivate Sub <\/span>Form_Timer()\r\n objRibbon_Reihenfolge.ActivateTab \"tabReihenfolge\"\r\n Me.TimerInterval = 0\r\nEnd Sub<\/span><\/pre>\n objRibbon_Reihenfolge Is Nothing<\/pre>\n
![\"Das](\"..\/fileadmin\/_temp_\/2019_04\/pic_1199_013.png\")
<\/p>\nPrivate Sub <\/span>Form_Load()\r\n ...\r\n Me.TimerInterval = 500\r\nEnd Sub<\/span><\/pre>\nRibbon-Tab als kontextabhängiges Tab<\/h2>\n
<xml version=\"1.0\">\r\n<customUI xmlns=\"http:\/\/schemas.microsoft.com\/office\/2009\/07\/customui\">\r\n <ribbon>\r\n <contextualTabs>\r\n <tabSet<\/span> idMso=\"TabSetFormReportExtensibility\">\r\n <tab id=\"tabReihenfolge\" label=\"Reihenfolge\">\r\n <group id=\"grpReihenfolgeAendern\" label=\"Reihenfolge ändern\">\r\n <button id=\"btnTop\" imageMso=\"ShapeUpArrow\" label=\"Ganz nach oben\" size=\"large\"\/>\r\n <button size=\"large\" id=\"btnUp\" imageMso=\"ShapeUpArrow\" label=\"Nach oben\"\/>\r\n <button id=\"btnDown\" imageMso=\"ShapeDownArrow\" label=\"Nach unten\" size=\"large\"\/>\r\n <button id=\"btnBottom\" imageMso=\"ShapeDownArrow\" label=\"Ganz nach unten\" size=\"large\"\/>\r\n <\/group>\r\n <\/tab>\r\n <\/tabSet>\r\n <\/contextualTabs>\r\n <\/ribbon>\r\n<\/customUI><\/pre>\n<button id=\"btnContext\" imageMso=\"AccessFormDatasheet\" label=\"Mehrfachreihenfolge Datenblatt Context\" onAction=\"onAction\" size=\"large\"\/><\/pre>\n
Sub <\/span>onAction(control As <\/span>IRibbonControl)\r\n Select Case control.Id\r\n Case <\/span>\"btnMehrfachreihenfolgeDatenblatt\"\r\n DoCmd.OpenForm _\r\n \"frmMehrfachreihenfolgeDatenblatt\"\r\n Case <\/span>\"btnContext\"\r\n DoCmd.OpenForm _\r\n \"frmMehrfachreihenfolgeDatenblattContext\"\r\n Case Else<\/span>\r\n Debug.Print<\/span> control.Id\r\n End Select<\/span>\r\nEnd Sub<\/span><\/pre>\n![\"Das](\"..\/fileadmin\/_temp_\/2019_04\/pic_1199_014.png\")
<\/p>\nTab mit startFromScratch exklusiv anzeigen<\/h2>\n
Unterformular vergrößern<\/h2>\n
Schaltflächen mit Funktion versehen<\/h2>\n
Public Function <\/span>cmdTop_Click()\r\n ...\r\nEnd Function<\/span><\/pre>\n![\"Diese](\"..\/fileadmin\/_temp_\/2019_04\/pic_1199_015.png\")
<\/p>\nPublic Function <\/span>btnTop_Click()\r\n ...\r\nEnd Function<\/span><\/pre>\n<button imageMso=\"ShapeUpArrow\" label=\"Ganz nach oben\" id=\"btnTop\" onAction=\"=btnTop_Click()\" size=\"large\"\/><\/pre>\n
Fehler beim Aufruf<\/h2>\n
![\"Fehlermeldung](\"..\/fileadmin\/_temp_\/2019_04\/pic_1199_016.png\")
<\/p>\nPublic Function <\/span>btnTop_Click()\r\n sfm_Exit False<\/span>\r\n ...\r\nEnd Function<\/span><\/pre>\nWeitere Schaltflächen<\/h2>\n
\n
Ribbon-Schaltflächen aktivieren und deaktivieren<\/h2>\n
Public <\/span>objRibbon_Reihenfolge As <\/span>IRibbonUI\r\nSub <\/span>onLoad_Reihenfolge(ribbon As <\/span>IRibbonUI)\r\n Set<\/span> objRibbon_Reihenfolge = ribbon\r\nEnd Sub<\/span><\/pre>\n<button imageMso=\"ShapeUpArrow\" label=\"Ganz nach oben\" id=\"btnTop\" onAction=\"=btnTop_Click()\" size=\"large\" getEnabled=\"getEnabled\"\/>\r\n<button id=\"btnUp\" imageMso=\"ShapeUpArrow\" label=\"Nach oben\" onAction=\"=btnUp_Click()\" size=\"large\" getEnabled=\"getEnabled\"\/>\r\n<button id=\"btnDown\" imageMso=\"ShapeDownArrow\" label=\"Nach unten\" onAction=\"=btnDown_Click()\" size=\"large\" getEnabled=\"getEnabled\"\/>\r\n<button id=\"btnBottom\" imageMso=\"ShapeDownArrow\" label=\"Ganz nach unten\" onAction=\"=btnBottom_Click()\" size=\"large\" getEnabled=\"getEnabled\"\/><\/pre>\n
![\"Die](\"..\/fileadmin\/_temp_\/2019_04\/pic_1199_018.png\")
<\/p>\nSub <\/span>getEnabled(control As <\/span>IRibbonControl, ByRef enabled)\r\nEnd Sub<\/span><\/pre>\n![\"Die](\"..\/fileadmin\/_temp_\/2019_04\/pic_1199_017.png\")
<\/p>\nPublic <\/span>bolBtnTopEnabled As Boolean<\/span>\r\nPublic <\/span>bolBtnUpEnabled As Boolean<\/span>\r\nPublic <\/span>bolBtnDownEnabled As Boolean<\/span>\r\nPublic <\/span>bolBtnBottomEnabled As Boolean<\/span><\/pre>\nSub <\/span>getEnabled(control As <\/span>IRibbonControl, ByRef enabled)\r\n Select Case control.Id\r\n Case <\/span>\"btnTop\"\r\n enabled = bolBtnTopEnabled\r\n Case <\/span>\"btnUp\"\r\n enabled = bolBtnUpEnabled\r\n Case <\/span>\"btnDown\"\r\n enabled = bolBtnDownEnabled\r\n Case <\/span>\"btnBottom\"\r\n enabled = bolBtnBottomEnabled\r\n End Select<\/span>\r\nEnd Sub<\/span><\/pre>\nPublic Sub <\/span>ActivateControls()\r\n Dim <\/span>bolErster As Boolean<\/span>\r\n Dim <\/span>bolLetzter As Boolean<\/span>\r\n Dim <\/span>lngAnzahl As Long<\/span><\/pre>\n