Ribbontab beim Öffnen eines Formulars anzeigen

Sie kennen sicher die Ribbon-Tabs, die erscheinen, wenn Sie bestimmte Objekte in Access öffnen. Wenn Sie eine neue Tabelle anlegen, erscheint beispielsweise ein Tab namens „Tabellenentwurf“. Wechseln Sie zur Datenblattansicht der Tabelle, erscheinen die Tabs „Tabelle Felder“ und „Tabelle“. Die Gemeinsamkeiten dieser Elemente sind, dass diese sich optisch ein wenig von den links davon befindlichen Tabs unterscheiden. Wie genau, hängt von der jeweils verwendeten Access-Version ab. In diesem Beitrag schauen wir uns an, wie wir überhaupt Ribbons mit einem Formular einblenden und dieses aktivieren und wie wir kontextabhängige Ribbons programmieren können.

Verschiedene Möglichkeiten

Wir stellen in diesem Beitrag die folgenden Varianten für das Anzeigen eines Ribbontabs beim Öffnen eines Formulars vor:

• Einfaches zusätzliches Tab, das mit dem Öffnen des Formulars erscheint, aber nicht aktiviert wird
• Tab, das alle anderen Elemente ausblendet und deshalb den Fokus erhält
• Tab, das als kontextabhängiges Tab ausgelegt ist und direkt mit dem Anzeigen des Formulars erscheint und aktiviert wird – aber nur beim ersten Aufruf des Formulars
• Zusätzliches Tab, das mit dem Formular erscheint und auch direkt aktiviert wird, und zwar bei jedem Öffnen des Formulars erneut.
• Die dort verwendete Technik wenden wir dann auch noch auf ein kontextabhängiges Tab an, damit dieses nicht nur beim ersten Anzeigen aktiviert wird, sondern bei jedem Öffnen des Formulars.

Vorbereitung für den Einsatz von Ribbons

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, welche die Ribbondefinitionen samt Bezeichnung speichert. Diese enthält die Felder ID, RibbonName (mit eindeutigem Index, damit jede Bezeichnung nur einmal vergeben wird) und RibbonXML und sieht im Entwurf wie in Bild 1 aus. Nach dem Speichern verschwindet diese Tabelle direkt, da die Bezeichnung USys… wie MSys… Systemobjekten vorbehalten ist, die nicht standardmäßig im Navigationsbereich angezeigt werden.

Bild 1: Tabelle zum Speichern der Ribbondefinitionen

Außerdem benötigen wir ein Modul namens mdlRibbons, in das wir den Code der durch das Ribbon ausgelösten Ereignisse schreiben sowie ein Modul namens mdlRibbonImages. 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 in den Access-Optionen unter Clienteinstellungen.

Definition des Anwendungsribbons, das die Formulare öffnet

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.

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 hinzu, der im Feld RibbonName den Wert Main enthält und im Feld RibbonXML das XML-Dokument.

<?xml version="1.0"?>
<customUI xmlns="http://schemas.microsoft.com/office/2009/07/customui" loadImage="loadImage">
   <ribbon startFromScratch="true">
     <tabs>
       <tab id="tabAnwendung" label="Anwendung">
         <group id="grpFormulare" label="Formulare">
           <button image="table_selection_row" label="Kundendetails" id="btnKundendetails" onAction="onAction" 
             size="large"/>
           <button image="form" label="Kundendetails StartFromScratch" 
             id="btnKundendetailsStartFromScratch" onAction="onAction" size="large"/>
           <button image="table_selection_all" label="Kundendetails Contextual" id="btnKundendetailsContextual" 
             onAction="onAction" size="large"/>
           <button image="tables" label="Kundendetails mit Fokus" id="btnKundendetailsFokus" onAction="onAction" 
             size="large"/>
           <button image="table_selection_cell" label="Kundendetails Contextual Fokus" 
             id="btnKundendetailsContextualFocus" onAction="onAction" size="large"/>
         </group>
       </tab>
     </tabs>
   </ribbon>
</customUI>

Listing 1: Definition des Anwendungsribbons

Im Ribbon-Dokument definieren wir ein Ribbon-Element, das durch den Wert True für das Attribut startFromScratch die eingebauten Elemente ausblendet – so ist es übersichtlicher. Außerdem enthält es fünf button-Elemente, die alle jeweils mit dem Attribut onAction ausgestattet sind.

Ribbon als Anwendungsribbon festlegen

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 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 unter Menüband- und Symbolleistenoptionen für die Eigenschaft Name des Menübands den Wert Main aus (siehe Bild 2).

Bild 2: Einstellen des Anwendungsribbons

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 einen Wert enthält und wendet dann die in der Tabelle USysRibbons gespeicherte Ribbondefinition an. Das Ergebnis sieht dann schließlich wie in Bild 3 aus.

Bild 3: Das von uns definierte Anwendungsribbon

Die onAction-Prozedur

Beim Anklicken einer der Ribbon-Schaltflächen, die mit dem onAction-Attribut versehen sind, rufen diese die Prozedur onAction auf, die wir im Modul mdlRibbons wie folgt hinterlegt haben:

Sub onAction(control As IRibbonControl)
     Select Case control.ID
         Case "btnKundenDetails"
             DoCmd.OpenForm "frmKundenDetails"
         Case "btnKundenDetailsStartFromScratch"
             DoCmd.OpenForm  "frmKundenDetails_StartFromScratch"
         Case "btnKundendetailsContextual"
             DoCmd.OpenForm "frmKundendetails_Contextual"
         Case "btnKundendetailsFokus"
             DoCmd.OpenForm "frmKundendetails_Fokus"
         Case "btnKundendetailsContextualFocus"
             DoCmd.OpenForm  "frmKundendetails_Contextual_Fokus"
         Case Else
             Debug.Print control.ID
     End Select
End Sub

Die Prozedur prüft jeweils, welches button-Element diese aufgerufen hat und öffnet im jeweiligen Case-Zweig der Select Case-Anweisung das entsprechende Formular.

Einfaches Formular-Tab

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-, ein group– und ein button-Element enthalten, das ebenfalls die oben bereits beschriebene onAction-Prozedur aufruft. Die Definition dieses Ribbons sieht wie in Listing 2 aus und wir fügen diese unter dem Namen Formularribbon zur Tabelle USysRibbons hinzu.

<?xml version="1.0"?>
<customUI xmlns="http://schemas.microsoft.com/office/2009/07/customui" loadImage="loadImage">
     <ribbon>
         <tabs>
             <tab id="tabFormular" label="Formular">
                 <group id="grpAllgemein" label="Allgemein">
                     <button image="close" label="Schließen" id="btnSchliessen" onAction="onAction" size="large"/>
                 </group>
             </tab>
         </tabs>
     </ribbon>
</customUI>

Listing 2: Definition eines einfachen Ribbons für ein Formular

Damit die onAction-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-Eintrag für den Wert btnSchliessen:

Sub onAction(control As IRibbonControl)
     Select Case control.ID
         Case "btnSchliessen"
             DoCmd.Close acForm, Screen.ActiveForm.Name
         ...
         Case Else
             Debug.Print control.ID
     End Select
End Sub

Hier nutzen wir einen kleinen Trick. Wir werden auch für alle weiteren Formulare einen Button namens btnSchliessen hinzufügen. Damit dieser immer das aktuelle Formular schließt, ermitteln wir mit Screen.ActiveForm.Name 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.

Damit die Ribbondefinition Formularribbon beim Öffnen des Formulars angewendet wird, müssen wir nach dem Hinzufügen zur Tabelle USysRibbons wieder die Anwendung schließen und erneut öffnen, dann das Formular in der Entwurfsansicht öffnen und für seine Eigenschaft Name des Menübands den Eintrag Formularribbon auswählen.

Ö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.

Bild 4: Das Ribbontab des neuen Formulars wird angezeigt, aber nicht direkt aktiviert.

Das geschieht erst nach einem Klick auf den Registerreiter Formular des Ribbons. Dann erscheint das Ribbontab wie in Bild 5. Ein Klick auf Schließen schließt das Formular wieder.

Bild 5: Das Tab des Formularribbons neben dem Anwendungsribbon

Formularribbon exklusiv anzeigen

Ende des frei verfügbaren Teil. Wenn Du mehr lesen möchtest, hole Dir ...

den kompletten Artikel im PDF-Format mit Beispieldatenbank

diesen und alle anderen Artikel mit dem Jahresabo