Ribbonklassen

Das Ribbon lässt sich normalerweise nur definieren, indem Sie den XML-Code zur Beschreibung des Ribbons festlegen, in einer bestimmten Tabelle speichern und die dortigen Einträge dann als Anwendungsribbon nutzen oder bestimmten Formularen oder Berichten zuweisen. Mit hier vorgestellten Klassen können Sie das Ribbon von nun an ganz einfach per VBA zusammenstellen und etwa Formularen oder Berichten zuweisen.

Wie funktioniert das nun – ein Ribbon anzuzeigen, ohne die Tabelle USysRibbons mit Ribbon-Definitionen zu füllen beziehungsweise gänzlich ohne statisch definierte Ribbons Grundsätzlich ist das ganz einfach: Sie benötigen lediglich einige Objekte aus der Beispieldatenbank zu diesem Beitrag, die Sie über die Importieren-Funktion in die Datenbank importieren, die Sie mit Ribbons ausstatten möchten.

Dabei handelt es sich um die folgenden Objekte:

• clsStartRibbon: Klasse, in der Sie das Hauptribbon einer Anwendung definieren
• Ribbons: Klasse, mit der Sie die Ribbons einer Anwendung verwalten
• clsRibbon: Klasse, die die Eigenschaften und Ereignisse des Ribbon-Elements bereitstellt
• clsTabs: Klasse, welche die Tabs verwaltet
• clsTab: Klasse, welche die Eigenschaften des Tab-Elements bereitstellt
• clsGroups: Klasse, welche die Gruppen eines Tab-Elements verwaltet
• clsGroup: Klasse, welche die Eigenschaften und Ereignisse des Group-Elements bereitstellt
• clsControls: Klasse, welche die Steuerelemente innerhalb einer Gruppe verwaltet
• clsButton: Klasse, welche die Funktionen des Button-Elements kapselt
• clsSeparator: Klasse, welche die Eigenschaften eines Separator-Elements kapselt
• mdlRibbons: Stellt einige globale Variablen bereit sowie die Funktionen zur Anzeige von Bilddateien
• mdlRibbonEnums: Modul, das einige Enumerationen enthält
• mdlTools: Enthält einige allgemeine Funktionen wie etwa zum Ermitteln von GUIDs oder zum Erstellen von formatierten XML-Dokumenten
• mdlZwischenablage: Enthält Funktionen, um Daten in die Zwischenablage zu kopieren und von dort abzufragen

Außerdem sind noch drei Schritte nötig:

• Sie fügen den Verweisen der Anwendung den Eintrag Microsoft Office x.0 Object Library hinzu (s. Bild 1).



Bild 1: Verweis auf die Office-Bibliothek

• Sie tragen für die Eigenschaft Name des Menü-bands in den Access-Optionen den Wert Main ein (s. Bild 2).



Bild 2: Option, um das Anwendungsribbon einzustellen

• Sie aktivieren die Option Fehler von Benutzeroberflächen-Add-Ins anzeigen in den Access-Optionen (s. Bild 3).



Bild 3: Aktivieren der Anzeige von Ribbon-Fehlern

Ribbons anzeigen

Zum Anzeigen von Ribbons gibt es auf herkömmlichem Wege zwei Möglichkeiten: Entweder Sie tragen den Namen der gewünschten Ribbon-Definition, die Sie in der Tabelle USysRibbons gespeichert haben, für die oben genannte Eigenschaft in den Access-Optionen ein – dann wird das entsprechende Ribbon gleich beim Anwendungsstart angezeigt. Oder Sie möchten, dass das Ribbon mit einem Formular oder Bericht eingeblendet wird.

Dann tragen Sie den Namen des Ribbons für die entsprechende Eigenschaft des Formulars oder Berichts ein.

Wir verwenden in der hier vorgestellten Lösung zwar keine Tabelle namens USysRibbons zum Speichern von Ribbon-Definitionen, aber wir können dennoch beide Methoden zum Anzeigen von Ribbons nutzen. Für die erste Methode ist die obige Angabe des Standardribbons nötig, beispielsweise über den Namen Main.

Außerdem brauchen Sie ein AutoExec-Makro, das dafür sorgt, dass das Ribbon auch direkt beim öffnen der Anwendung angezeigt wird.

Dieses Makro definieren Sie wie in Bild 4. Der einzige Makrobefehl lautet AusführenCode und ruft die Funktion RibbonLaden auf. Diese Funktion ist im Modul mdlRibbons definiert und sieht wie folgt aus:

Bild 4: AutoExec-Makro, das ein Ribbon einblenden soll

Public Function RibbonLaden()
     Startribbon.CreateRibbon
End Function

Hier wird also die Methode CreateRibbon eines Objekts namens Startribbon aufgerufen. Wie Sie weiter oben sehen, haben wir die entsprechende Klasse Startribbon bereits in der Beispieldatenbank vorbereitet. Aber wie können wir die Methode CreateRibbon dieser Klasse nutzen, ohne dass wir diese instanzieren Das ist kein Problem: Wie müssen die Klasse nur einmal in eine Textdatei exportieren und dann einige Eigenschaften, die im VBA-Editor nicht sichtbar sind, anpassen. In Bild 5 haben wird dies für die Klasse Ribbons durchgeführt, die ebenfalls ohne Instanzierung genutzt werden soll.

Bild 5: Anpassen der Klasse Ribbons, damit diese nicht instanziert werden muss

Nun wollen wir in der Klasse StartRibbon eine Methode namens CreateRibbon anlegen, mit der wir ein Ribbon namens Main definieren, das dann beim öffnen der Anwendung gleich angezeigt werden soll.

Public Sub CreateRibbon()
     ...
End Sub

In dieser deklarieren wir nun zunächst ein Objekt des Typs clsRibbon, das unsere Ribbon-Deklaration aufnimmt.

Dim objRibbon As clsRibbon

Wir wollen als Erstes lediglich ein leeres Tab-Element hinzufügen, um zu zeigen, dass die Klassen auch wirklich ihr Werk verrichten. Dazu deklarieren wir auch noch ein Element des Typs clsTab:

Dim objTab As clsTab

Das clsRibbon-Element füllen wir dann mit einem Objekt, das die Add-Methode der Ribbons-Klasse liefert:

     Set objRibbon = Ribbons.Add("Main")

Dieses Objekt besitzt wie das entsprechende Element in der Ribbon-Definition eine Eigenschaft namens StartFromScratch, die wir auf den Wert True einstellen:

     With objRibbon
         .StartFromScratch = True

Dann fügen wir dem clsRibbon-Element mit der Add-Methode der Tabs-Auflistung ein neues Tab-Element hinzu. Den Namen übergeben wir als Parameter:

Set objTab = .Tabs.Add("Beispieltab")

Für dieses Objekt legen wir die Beschriftung mit der Eigenschaft label fest:

         With objTab
             .label = "Beispieltab"
         End With
     End With

Danach rufen wir die Methode CreateStartRibbon der Klasse Ribbons auf und übergeben dieser den Namen des zu erstellenden Ribbons, also Main:

     Ribbons.CreateStartRibbon "Main"
End Sub

Die vollständige Fassung dieser Prozedur finden Sie in Listing 1.

Public Sub CreateRibbon()
     Dim objRibbon As clsRibbon
     Dim objTab As clsTab
     Set objRibbon = Ribbons.Add("Main")
     With objRibbon
         .StartFromScratch = True
         Set objTab = .Tabs.Add("Beispieltab")
         With objTab
             .label = "Beispieltab"
         End With
     End With
     Ribbons.CreateStartRibbon "Main"
End Sub

Listing 1: Die Methode CreateRibbon füllen Sie mit eigenen Anweisungen.

Anschließend schauen wir uns an, ob diese Art der Ribbon-Definition auch wirklich funktioniert. Dazu schließen Sie die Access-Datei und öffnen diese erneut, damit das AutoExec-Makro ausgeführt wird. Es reicht nicht aus, einfach das Makro auszuführen, da das Main-Ribbon möglicherweise zu diesem Zeitpunkt schon installiert wurde und erneutes Anlegen zu einem Fehler führt (dies können Sie durch erneutes Aufrufen des AutoExec-Makros ausprobieren). Beim erneuten öffnen der Anwendung sollte nun die Ansicht aus Bild 6 erscheinen. Es funktioniert!

Bild 6: Das erste per VBA-Code erzeugte Ribbon

Gruppen und Schaltflächen hinzufügen

Nun gehen wir einen Schritt weiter und wollen dem Tab-Element eine Gruppe hinzufügen – und natürlich auch noch Button-Elemente. Die einfachste Variante sieht nun wie in Listing 2 aus. Sie sehen hier, dass wir ein weiteres Objekt des Typs clsGroup mit dem Variablennamen obj-Group deklariert haben. Dieses fügen wir dann über die Add-Methode der Groups-Auflistung des clsTab-Objekts zum Ribbon hinzu. Auch dieses Objekt hält eine Eigenschaft namens label bereit, mit der Sie die Beschriftung der Gruppe festlegen können. Diese legen wir hier mit dem Ausdruck Beispielgruppe fest.

Public Sub CreateRibbon()
     Dim objRibbon As clsRibbon
     Dim objTab As clsTab
     Dim objGroup As clsGroup
     Set objRibbon = Ribbons.Add("Main")
     With objRibbon
         .StartFromScratch = True
         Set objTab = .Tabs.Add("Beispieltab")
         With objTab
             .label = "Beispieltab"
             Set objGroup = .Groups.Add("Beispielgruppe")
             With objGroup
                 .label = "Beispielgruppe"
                 Set objButton1 = .Controls.Add(msoRibbonControlButton, "Beispielbutton")
                 objButton1.label = "Button 1"
                 Set objButton2 = .Controls.Add(msoRibbonControlButton, "Beispielbutton1")
                 objButton2.label = "Button 2"
             End With
         End With
     End With
     Ribbons.CreateStartRibbon "Main"
End Sub

Listing 2: Anlegen eines Ribbons, diesmal mit einer Gruppe und zwei Schaltflächen

Danach folgen die beiden Button-Elemente: Das erste fügen wir mit der Methode Add der Auflistung Controls des Objekts objGroup hinzu. Dabei geben wir als ersten Parameter den Wert msoRibbonControlButton an, was bewirkt, dass hier ein Button-Element angelegt wird. Mit dem zweiten Parameter übergeben wir den Namen dieses Button-Elements. Danach legen wir wiederum mit der Eigenschaft label die Bezeichnung des Button-Elements fest.

Wenn Sie aufgepasst haben, fällt Ihnen auf, dass die Prozedur gar keine Deklaration für die beiden Button-Elemente objButton1 und objButton2 enthält.

Das hat folgenden Grund: Unter anderem soll die Verwendung dieser Lösung dafür sorgen, dass Sie richtige Ereignisprozeduren für die Steuerelemente des Ribbons hinterlegen können. Das heißt, dass Sie die Ribbon-Elemente, die Ereignisse auslösen, mit dem Schlüsselwort WithEvents deklarieren und dafür entsprechende Ereignisprozeduren anlegen können.

Das gelingt, indem Sie zunächst die Deklaration im Kopf des Klassenmoduls vornehmen – für unsere beiden Schaltflächen also wie folgt:

Dim WithEvents objButton1 As clsButton
Dim WithEvents objButton2 As clsButton

Dann verwenden Sie die beiden Kombinationsfelder im Kopf des Modulfensters und wählen dort im linken Element den Namen des betroffenen Steuerelements, zum Beispiel objButton1, und im rechten den Eintrag OnAction aus. Dies legt dann automatisch die passende Ereignisprozedur an, die wir mit einer Test-Meldung füllen (s. Bild 7):

Bild 7: Deklarieren von Button-Elementen und Implementieren ihrer Ereignisse

Private Sub objButton1_OnAction(control As RibbonControl)
     MsgBox control.id
End Sub
Private Sub objButton2_OnAction(control As IRibbonControl)
     MsgBox control.id
End Sub

In dieser Prozedur können wir dann gleich den Verweis auf das entsprechende Steuerelement nutzen, der mit dem Parameter control geliefert wird.

Dies bietet zum Beispiel mit der Eigenschaft id den Namen des angeklickten Steuerelements an, den wir hier gleich per Meldungsfenster ausgeben. Das Ergebnis des aktuellen Stands finden Sie in Bild 8.

Bild 8: Test der neuen Button-Elemente

Große Schaltflächen mit Bildern

Nun wollen wir natürlich auch die optischen Möglichkeiten des Ribbons nutzen und die Schaltflächen größer und mit Bildern anzeigen. Die dazu benötigten Bilder fügen Sie zur Systemtabelle MSysResources hinzu.

Das gelingt am einfachsten, indem Sie ein Formular in der Entwurfsansicht öffnen und dann im Ribbon den Eintrag Entwurf|Steuerelemente|Bild einfügen anklicken. Hier erscheint dann ein Eintrag namens Durchsuchen…, mit dem Sie einen Grafik einfügen-Dialog öffnen können (s. Bild 9).

Bild 9: Hinzufügen von Bildern zur Tabelle MSysResources

Damit fügen Sie dann die Bilddateien hinzu – für kleine Schaltflächen in der Größe 16×16, für große Schaltflächen in 32×32. Wenn Sie zuvor nicht das Formular anklicken, werden die Bilddateien noch nicht einmal direkt zum Formular hinzugefügt, sondern nur zur Tabelle MSysResources.

Diese sieht dann etwa wie in Bild 10 aus. Die Definition passen wir nun wie folgt an:

Bild 10: Bilder in der Tabelle MSysResources

Set objButton1 = .Controls.Add( msoRibbonControlButton, "Beispielbutton")
With objButton1
     .label = "Button 1"
     .Size = msoRibbonControlSizelarge
     .image = "add"
End With
Set objButton2 = .Controls.Add( msoRibbonControlButton, "Beispielbutton1")
With objButton2
     .label = "Button 2"
     .Size = msoRibbonControlSizelarge
     .image = "close"
End With

Wir haben hier erstens die Größe der Schaltflächen mit dem Wert msoRibbonControlSizeLarge für die Eigenschaft Size auf große Icons umgestellt.

Außerdem haben wir der Eigenschaft image jeweils den Namen des anzuzeigenden Bildes hinzugefügt. Das Ergebnis sieht dann wie in Bild 11 aus.

Bild 11: Anzeige benutzerdefinierter Bilder

Eingebaute Icons

Sie können auch eines der zahlreichen eingebauten Icons nutzen. Diese lassen sich per IntelliSense abrufen, wenn Sie die Eigenschaft imageMso verwenden (s. Bild 12).

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