Vorbereitung für den Einsatz von Ribbons<\/h2>\n
Bevor wir uns die Eigenarten der verschiedenen Ribbondefinitionen ansehen, schaffen wir die Voraussetzungen für die Anzeige von Ribbons. Dazu benötigen wir als Erstes eine Tabelle namens USysRibbons<\/b>, welche die Ribbondefinitionen samt Bezeichnung speichert. Diese enthält die Felder ID<\/b>, RibbonName <\/b>(mit eindeutigem Index, damit jede Bezeichnung nur einmal vergeben wird) und RibbonXML<\/b> und sieht im Entwurf wie in Bild 1 aus. Nach dem Speichern verschwindet diese Tabelle direkt, da die Bezeichnung USys… <\/b>wie MSys… <\/b>Systemobjekten vorbehalten ist, die nicht standardmäßig im Navigationsbereich angezeigt werden.<\/p>\n
![\"Tabelle](\"..\/fileadmin\/_temp_\/2022_06\/pic_1391_001.png\")
<\/p>\n
Bild 1: Tabelle zum Speichern der Ribbondefinitionen<\/span><\/b><\/p>\n Außerdem benötigen wir ein Modul namens mdlRibbons<\/b>, in das wir den Code der durch das Ribbon ausgelösten Ereignisse schreiben sowie ein Modul namens mdlRibbonImages<\/b>. Dieses können Sie aus der Beispieldatenbank herauskopieren – sie ist bereits mit einigen Routinen gefüllt, welche die Anzeige von Bildern im Ribbon ermöglichen. Um Fehler in den Ribbondefinitionen zu erkennen, aktivieren wir die Option Fehler von Benutzeroberflächen-Add-Ins anzeigen <\/b>in den Access-Optionen unter Clienteinstellungen<\/b>.<\/p>\n Als Erstes erstellen wir eine Ribbondefinition, die beim Öffnen der Anwendung erscheint und Schaltflächen enthält, mit denen wir die Formulare der nachfolgend beschriebenen Beispiele öffnen können. Diesen weisen wir dann jeweils eine Ribbondefinition zu, die mit dem Öffnen des Formulars angewendet wird.<\/p>\n Diese Definition sieht wie in Listing 1 aus und damit sie für die Anwendung verfügbar ist, fügen wir einen neuen Datensatz zur Tabelle USysRibbons <\/b>hinzu, der im Feld RibbonName <\/b>den Wert Main <\/b>enthält und im Feld RibbonXML <\/b>das XML-Dokument. <\/p>\n Listing 1: Definition des Anwendungsribbons<\/span><\/b><\/p>\n Im Ribbon-Dokument definieren wir ein Ribbon<\/b>-Element, das durch den Wert True <\/b>für das Attribut startFromScratch <\/b>die eingebauten Elemente ausblendet – so ist es übersichtlicher. Außerdem enthält es fünf button<\/b>-Elemente, die alle jeweils mit dem Attribut onAction <\/b>ausgestattet sind. <\/p>\n Damit die Anwendung dieses Ribbon beim Öffnen anzeigt, müssen wir dieses als Anwendungsribbon festlegen. Damit dies überhaupt möglich ist, muss Access dieses Ribbon erst einmal als vorhanden erkennen. Das einfache Hinzufügen eines Datensatzes zur Tabelle USysRibbons <\/b>reicht dazu nicht aus, da die Inhalte nur beim Öffnen der Access-Datenbank eingelesen werden. Daher schließen wir die Datenbankanwendung und öffnen diese erneut. Anschließend können wir die Ribbondefinition in den Access-Optionen als Anwendungsribbon einstellen. Dazu wählen wir dort im Bereich Aktuelle Datenbank <\/b>unter Menüband- und Symbolleistenoptionen <\/b>für die Eigenschaft Name des Menübands <\/b>den Wert Main <\/b>aus (siehe Bild 2).<\/p>\n Bild 2: Einstellen des Anwendungsribbons<\/span><\/b><\/p>\n Damit die Anwendung dieses Ribbon anzeigt, müssen wir sie nun nochmals schließen und erneut öffnen. Erst dann prüft Access beim Öffnen, ob die Eigenschaft Name des Menübands <\/b>einen Wert enthält und wendet dann die in der Tabelle USysRibbons<\/b> gespeicherte Ribbondefinition an. Das Ergebnis sieht dann schließlich wie in Bild 3 aus.<\/p>\n Bild 3: Das von uns definierte Anwendungsribbon<\/span><\/b><\/p>\n Beim Anklicken einer der Ribbon-Schaltflächen, die mit dem onAction<\/b>-Attribut versehen sind, rufen diese die Prozedur onAction <\/b>auf, die wir im Modul mdlRibbons <\/b>wie folgt hinterlegt haben:<\/p>\n Die Prozedur prüft jeweils, welches button<\/b>-Element diese aufgerufen hat und öffnet im jeweiligen Case<\/b>-Zweig der Select Case<\/b>-Anweisung das entsprechende Formular.<\/p>\n Im ersten Beispiel wollen wir überhaupt zeigen, wie wir mit einem Formular eine neue Ribbon-Definition anwenden können. Diese soll einfach nur ein tab<\/b>-, ein group<\/b>– und ein button<\/b>-Element enthalten, das ebenfalls die oben bereits beschriebene onAction<\/b>-Prozedur aufruft. Die Definition dieses Ribbons sieht wie in Listing 2 aus und wir fügen diese unter dem Namen Formularribbon <\/b>zur Tabelle USysRibbons <\/b>hinzu.<\/p>\n <\/p>\n Listing 2: Definition eines einfachen Ribbons für ein Formular<\/span><\/b><\/p>\n Damit die onAction<\/b>-Prozedur beim Anklicken der Schaltfläche etwas tut, in diesem Fall das Formular wieder zu schließen, erweitern wir die Prozedur wie folgt um einen Case<\/b>-Eintrag für den Wert btnSchliessen<\/b>:<\/p>\n Hier nutzen wir einen kleinen Trick. Wir werden auch für alle weiteren Formulare einen Button namens btnSchliessen <\/b>hinzufügen. Damit dieser immer das aktuelle Formular schließt, ermitteln wir mit Screen.ActiveForm.Name <\/b>den Namen des aktuell geöffneten Formulars. Dabei erhalten wir zwingend den Namen des passenden Formulars, weil ohne dieses ja nicht das entsprechende Ribbon angezeigt würde.<\/p>\n Damit die Ribbondefinition Formularribbon <\/b>beim Öffnen des Formulars angewendet wird, müssen wir nach dem Hinzufügen zur Tabelle USysRibbons <\/b>wieder die Anwendung schließen und erneut öffnen, dann das Formular in der Entwurfsansicht öffnen und für seine Eigenschaft Name des Menübands <\/b>den Eintrag Formularribbon <\/b>auswählen.<\/p>\n Öffnen wir dann das Formular, erhalten wir die Darstellung aus Bild 4. Das für das Formular definierte Ribbontab wird zwar angezeigt, aber nicht aktiviert.<\/p>\n Bild 4: Das Ribbontab des neuen Formulars wird angezeigt, aber nicht direkt aktiviert.<\/span><\/b><\/p>\n Das geschieht erst nach einem Klick auf den Registerreiter Formular<\/b> des Ribbons. Dann erscheint das Ribbontab wie in Bild 5. Ein Klick auf Schließen <\/b>schließt das Formular wieder.<\/p>\n Bild 5: Das Tab des Formularribbons neben dem Anwendungsribbon<\/span><\/b><\/p>\n Wie erreichen wir es, dass das Tab für das Formular direkt beim Öffnen des Formulars angezeigt wird? Eine einfache Möglichkeit ist es, die Eigenschaft StartFromScratch <\/b>für das ribbon<\/b>-Element der Ribbondefinition direkt auf den Wert true <\/b>einzustellen.<\/p>\n Dies erledigen wir für das Ribbon des durch die zweite Schaltfläche des Anwendungsribbons geöffneten Formulars. Das Formular soll den Namen frmKundenDetails_StartFromScratch <\/b>erhalten. Der Name der zur Tabelle USysRibbons <\/b>neu hinzugefügten Ribbondefinition lautet FormularRibbon_StartFromScratch<\/b>. Die Ribbondefinition selbst unterscheidet sich nur durch das Attribut StartFromScratch <\/b>von der zuvor verwendeten. Diese fügen wir wie folgt für das Element ribbon <\/b>ein:<\/p>\n Nach dem Hinzufügen der Ribbondefinition zur Tabelle USysRibbons <\/b>ist der obligatorische Neustart nötig, danach können wir die Ribbondefinition der Eigenschaft Name des Menübands <\/b>des Formulars frmKundenDetails_StartFromScratch <\/b>hinzufügen.<\/p>\n Nachdem wir dieses Formular durch einen Klick auf den Button mit der Beschriftung Kundendetails StartFromScratch <\/b>des Anwendungsribbons geöffnet haben, erscheint dieses wie in Bild 6.<\/p>\n Bild 6: Das Tab des Formularribbons als einziges Tab<\/span><\/b><\/p>\n Damit haben wir zwar eine Möglichkeit gefunden, das Tab<\/b>-Element des Formulars direkt anzuzeigen, aber das Anwendungsribbon wird nicht mehr angezeigt. Um das zu realisieren, gibt es die kontextabhängigen Tabs. Diese definieren wir auf eine bestimmte Art (siehe Listing 3). Dazu verwenden wir unterhalb des ribbon<\/b>-Elements zunächst ein contextualTabs<\/b>-Element, das wiederum ein tabSet<\/b>-Element enthält. Damit dieses in Zusammenhang mit einem Formular oder Bericht angezeigt wird, für dessen Eigenschaft Name des Menübands <\/b>es festgelegt wurde, müssen wir das Attribut idMso <\/b>des tabSet<\/b>-Elements auf den Wert TabSetFormReportExtensibility <\/b>einstellen. Das sorgt nicht nur dafür, dass dieses tab<\/b>-Element nur mit einem Formular angezeigt wird, sondern auch für die optisch hervorgehobene Darstellung.<\/p>\n Listing 3: Definition eines Formularribbons mit kontextabhängigem Tab<\/span><\/b><\/p>\n Wir weisen nach dem Hinzufügen dieser Definition zur Tabelle USysRibbons <\/b>unter dem Namen FormularRibbon_Contextual <\/b>und dem Neustart der Anwendung das Ribbon einem weiteren Formular namens frmKundenDetails_Contextual <\/b>zu. Öffnen wir dieses nun, erhalten wir die Darstellung aus Bild 7.<\/p>\n Bild 7: Das kontextabhängige Tab wird direkt mit dem Formular angezeigt.<\/span><\/b><\/p>\n Ist das die ultimative Lösung? Nein, denn wenn wir nun ein anderes Formular öffnen, führt das wie erwartet zum Ausblenden des kontextabhängigen Tabs. Aktivieren wir das Formular frmKundendetails_Contextual <\/b>dann erneut, wird zwar das kontextabhängige tab<\/b>-Element wieder angezeigt, aber nicht aktiviert (siehe Bild 8). Wir würden uns aber eher wünschen, dass dieses Element auch wieder aktiviert wird, wenn das Formular den Fokus zurückerhält. Wie das gelingt, zeigen wir im nächsten Beispiel.<\/p>\n Bild 8: Es erfolgt aber keine erneute Aktivierung, wenn man ein anderes Formular anzeigt und dann zu dem mit dem kontextabhängigen Formular zurückspringt.<\/span><\/b><\/p>\n Damit das Ribbontab immer direkt mit mit dem Formular aktiviert wird, benötigen wir ein wenig zusätzlichen VBA-Code und das onLoad<\/b>-Attribut. Dieses fügen wir in der Ribbondefinition wie in Listing 4 zum Element customUI <\/b>hinzu. Die hier angegebene Prozedur OnLoad_FormularribbonFokus <\/b>legen wir im Modul mdlRibbons <\/b>wie folgt an:<\/p>\n Listing 4: Definition eines Formularribbons, das immer mit dem Formular aktiviert wird<\/span><\/b><\/p>\n Dort weisen wir zuerst der Variablen objRibbon_FormularribbonFokus <\/b>eine Referenz auf die mit der Ribbondefinition erstellten Erweiterung zu. Damit dies klappt, müssen wir die Variable im gleichen Modul zunächst deklarieren, was wir wie folgt erledigen:<\/p>\n Nachdem wir diese Variable deklariert und mit der ersten Anweisung der onLoad<\/b>-Prozedur gefüllt haben, rufen wir gleich eine Methode dieses Objekts auf, und zwar ActivateTab<\/b>, und übergeben dieser den Namen des tab<\/b>-Elements tabFormularContextualFokus<\/b>. Dies sorgt dafür, dass das tab<\/b>-Element direkt beim Anzeigen des Formulars angezeigt und aktiviert wird. Das reicht allerdings noch nicht aus, um das Verhalten des vorherigen Beispiels zu optimieren – wenn wir zwischendurch ein anderes Formular öffnen und dieses dann wieder schließen, wird das Ribbontab des Formulars frmKundendetails_Fokus <\/b>zwar wieder angezeigt, aber nicht aktiviert. Das erreichen wir erst, wenn wir noch eine weitere Ereignisprozedur zum Formular hinzufügen. Diese hinterlegen wir für das Ereignis Bei Aktivierung<\/b>.<\/p>\n Die Prozedur führt im Wesentlichen die ActivateTab<\/b>-Methode des IRibbonUI<\/b>-Objekts objRibbon_FormularRibbonContextualFokus <\/b>aus, um das Tab wieder zu aktivieren:<\/p>\n Dies allein würde jedoch zu einem Fehler führen, wenn das Ereignis beim Öffnen des Formulars ausgeführt wird. Zu diesem Zeitpunkt wurde die Ribbondefinition nämlich noch nicht angewendet, weshalb auch objRibbon_FormularribbonFokus <\/b>noch nicht gefüllt ist. Der Versuch, ActivateTab <\/b>aufzurufen, führt daher zu einem Fehler. Also schließen wir diese Anweisung in eine If…Then<\/b>-Bedingung ein, die prüft, ob die Variable nicht den Wert Nothing <\/b>enthält, also noch leer ist.<\/p>\n Sobald das Formular einmal geöffnet ist und zwischendurch ein anderes Formular den Fokus erhält, sorgt diese Prozedur beim Anzeigen des Formulars jedoch wieder für die Aktivierung des dazugehörigen Ribbontabs.<\/p>\n Und dass die Beim Aktivieren<\/b>-Ereignisprozedur direkt beim Öffnen des Formulars noch auf eine leere Variable objRibbon_FormularribbonFokus <\/b>stößt, ist kein Problem, denn hier rufen wir ja in der onLoad<\/b>-Prozedur die ActivateTab<\/b>-Methode des IRibbonUI<\/b>-Objekts auf.<\/p>\n Vielleicht ist Ihnen das noch nicht genug und Sie möchten dieses Verhalten auch für ein Ribbontab abbilden, das als kontextabhängiges Tab definiert wurde. Wie das gelingt, zeigen wir im letzten Beispiel. Dieses verwendet die Ribbondefinition aus Listing 5. Hier haben wir wieder das Attribut onLoad <\/b>im customUI<\/b>-Element, das die folgende Variablendeklaration benötigt:<\/p>\nDefinition des Anwendungsribbons, das die Formulare öffnet<\/h2>\n
<?xml version=\"1.0\"?>\r\n<customUI xmlns=\"http:\/\/schemas.microsoft.com\/office\/2009\/07\/customui\" loadImage=\"loadImage\">\r\n <ribbon startFromScratch=\"true\">\r\n <tabs>\r\n <tab id=\"tabAnwendung\" label=\"Anwendung\">\r\n <group id=\"grpFormulare\" label=\"Formulare\">\r\n <button image=\"table_selection_row\" label=\"Kundendetails\" id=\"btnKundendetails\" onAction=\"onAction\" \r\n size=\"large\"\/>\r\n <button image=\"form\" label=\"Kundendetails StartFromScratch\" \r\n id=\"btnKundendetailsStartFromScratch\" onAction=\"onAction\" size=\"large\"\/>\r\n <button image=\"table_selection_all\" label=\"Kundendetails Contextual\" id=\"btnKundendetailsContextual\" \r\n onAction=\"onAction\" size=\"large\"\/>\r\n <button image=\"tables\" label=\"Kundendetails mit Fokus\" id=\"btnKundendetailsFokus\" onAction=\"onAction\" \r\n size=\"large\"\/>\r\n <button image=\"table_selection_cell\" label=\"Kundendetails Contextual Fokus\" \r\n id=\"btnKundendetailsContextualFocus\" onAction=\"onAction\" size=\"large\"\/>\r\n <\/group>\r\n <\/tab>\r\n <\/tabs>\r\n <\/ribbon>\r\n<\/customUI><\/pre>\n
Ribbon als Anwendungsribbon festlegen<\/h2>\n
![\"Einstellen](\"..\/fileadmin\/_temp_\/2022_06\/pic_1391_002.png\")
<\/p>\n![\"Das](\"..\/fileadmin\/_temp_\/2022_06\/pic_1391_003.png\")
<\/p>\nDie onAction-Prozedur<\/h2>\n
Sub <\/span>onAction(control As <\/span>IRibbonControl)\r\n Select Case control.ID\r\n Case <\/span>\"btnKundenDetails\"\r\n DoCmd.OpenForm \"frmKundenDetails\"\r\n Case <\/span>\"btnKundenDetailsStartFromScratch\"\r\n DoCmd.OpenForm \"frmKundenDetails_StartFromScratch\"\r\n Case <\/span>\"btnKundendetailsContextual\"\r\n DoCmd.OpenForm \"frmKundendetails_Contextual\"\r\n Case <\/span>\"btnKundendetailsFokus\"\r\n DoCmd.OpenForm \"frmKundendetails_Fokus\"\r\n Case <\/span>\"btnKundendetailsContextualFocus\"\r\n DoCmd.OpenForm \"frmKundendetails_Contextual_Fokus\"\r\n Case Else<\/span>\r\n Debug.Print<\/span> control.ID\r\n End Select<\/span>\r\nEnd Sub<\/span><\/pre>\nEinfaches Formular-Tab<\/h2>\n
<?xml version=\"1.0\"?>\r\n<customUI xmlns=\"http:\/\/schemas.microsoft.com\/office\/2009\/07\/customui\" loadImage=\"loadImage\">\r\n <ribbon>\r\n <tabs>\r\n <tab id=\"tabFormular\" label=\"Formular\">\r\n <group id=\"grpAllgemein\" label=\"Allgemein\">\r\n <button image=\"close\" label=\"Schließen\" id=\"btnSchliessen\" onAction=\"onAction\" size=\"large\"\/>\r\n <\/group>\r\n <\/tab>\r\n <\/tabs>\r\n <\/ribbon>\r\n<\/customUI><\/pre>\n
Sub <\/span>onAction(control As <\/span>IRibbonControl)\r\n Select Case control.ID\r\n Case <\/span>\"btnSchliessen\"\r\n DoCmd.Close acForm, Screen.ActiveForm.Name\r\n ...\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_\/2022_06\/pic_1391_004.png\")
<\/p>\n![\"Das](\"..\/fileadmin\/_temp_\/2022_06\/pic_1391_005.png\")
<\/p>\nFormularribbon exklusiv anzeigen<\/h2>\n
<?xml version=\"1.0\"?>\r\n<customUI ... loadImage=\"loadImage\">\r\n <ribbon startFromScratch=\"true\">\r\n ...\r\n <\/ribbon>\r\n<\/customUI><\/pre>\n
![\"Das](\"..\/fileadmin\/_temp_\/2022_06\/pic_1391_006.png\")
<\/p>\nKontextabhängiges Tab-Element<\/h2>\n
<?xml version=\"1.0\"?>\r\n<customUI xmlns=\"http:\/\/schemas.microsoft.com\/office\/2009\/07\/customui\" loadImage=\"loadImage\">\r\n <ribbon>\r\n <contextualTabs>\r\n <tabSet<\/span> idMso=\"TabSetFormReportExtensibility\">\r\n <tab id=\"tabFormularContextual\" label=\"Formular Contextual\">\r\n <group id=\"grpAllgemein\" label=\"Allgemein\">\r\n <button image=\"close\" label=\"Schließen\" id=\"btnSchliessen\" onAction=\"onAction\" size=\"large\"\/>\r\n <\/group>\r\n <\/tab>\r\n <\/tabSet>\r\n <\/contextualTabs>\r\n <\/ribbon>\r\n<\/customUI><\/pre>\n![\"Das](\"..\/fileadmin\/_temp_\/2022_06\/pic_1391_007.png\")
<\/p>\n![\"Es](\"..\/fileadmin\/_temp_\/2022_06\/pic_1391_008.png\")
<\/p>\nTab eines Formularribbons immer mit Formular aktivieren<\/h2>\n
<?xml version=\"1.0\"?>\r\n<customUI ... onLoad=\"OnLoad_FormularribbonFokus\" loadImage=\"loadImage\">\r\n <ribbon>\r\n <tabs>\r\n <tab id=\"tabFormularFokus\" label=\"Formular Fokus\">\r\n <group id=\"grpAllgemein\" label=\"Allgemein\">\r\n <button id=\"btnSchliessen\" image=\"close\" label=\"Schließen\" onAction=\"onAction\" size=\"large\"\/>\r\n <\/group>\r\n <\/tab>\r\n <\/tabs>\r\n <\/ribbon>\r\n<\/customUI><\/pre>\n
Sub <\/span>onLoad_FormularRibbonContextualFokus( ribbon As <\/span>IRibbonUI)\r\n Set<\/span> objRibbon_FormularRibbonContextualFokus = ribbon\r\n objRibbon_FormularRibbonContextualFokus.ActivateTab \"tabFormularContextualFokus\"\r\nEnd Sub<\/span><\/pre>\nPublic <\/span>objRibbon_FormularribbonFokus As <\/span>IRibbonUI<\/pre>\nPrivate Sub <\/span>Form_Activate()\r\n If <\/span>Not<\/span> objRibbon_FormularribbonFokus Is Nothing Then<\/span>\r\n objRibbon_FormularribbonFokus.ActivateTab \"tabFormularFokus\"\r\n End If<\/span>\r\nEnd Sub<\/span><\/pre>\nKontextabhängiges Tab plus Fokus nach Formularwechsel<\/h2>\n
<?xml version=\"1.0\"?>\r\n<customUI ... onLoad=\"OnLoad_FormularRibbonContextualFokus\" loadImage=\"loadImage\">\r\n <ribbon>\r\n <contextualTabs>\r\n <tabSet<\/span> idMso=\"TabSetFormReportExtensibility\">\r\n <tab id=\"tabFormularContextualFokus\" label=\"Formular Contextual Fokus\">\r\n <group id=\"grpAllgemein\" label=\"Allgemein\">\r\n <button id=\"btnSchliessen\" image=\"close\" label=\"Schließen\" onAction=\"onAction\" size=\"large\"\/>\r\n <\/group>\r\n <\/tab>\r\n <\/tabSet>\r\n <\/contextualTabs>\r\n <\/ribbon>\r\n<\/customUI><\/pre>\n