Zur Hauptseite ... Zum Onlinearchiv ... Zum Abonnement ... Zum Newsletter ... Zu den Tools ... Zum Impressum ... Zum Login ...

Achtung: Dies ist nicht der vollständige Artikel, sondern nur ein paar Seiten davon. Wenn Sie hier nicht erfahren, was Sie wissen möchten, finden Sie am Ende Informationen darüber, wie Sie den ganzen Artikel lesen können.

Kompletten Artikel lesen?

Einfach für den Newsletter anmelden, dann lesen Sie schon in einer Minute den kompletten Artikel und erhalten die Beispieldatenbanken.

E-Mail:

Gedrucktes Heft

Diesen Beitrag finden Sie in Ausgabe 1/2017.

Unser Angebot für Sie!

Lesen Sie diesen Beitrag und 500 andere sofort im Onlinearchiv, und erhalten Sie alle zwei Monate brandheißes Access-Know-how auf 72 gedruckten Seiten! Plus attraktive Präsente, zum Beispiel das bald erscheinende Buch 'Access 2010 - Das Grundlagenbuch für Entwickler'!

Diesen Beitrag twittern

Objektorientierte Ribbon-Programmierung

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).
  • Verweis auf die Office-Bibliothek

    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).
  • Option, um das Anwendungsribbon einzustellen

    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).
  • Aktivieren der Anzeige von Ribbon-Fehlern

    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:

AutoExec-Makro, das ein Ribbon einblenden soll

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.

Anpassen der Klasse Ribbons, damit diese nicht instanziert werden muss

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!

Das erste per VBA-Code erzeugte Ribbon

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.

Sie haben das Ende des frei verfügbaren Teils des Artikels erreicht. Lesen Sie weiter, um zu erfahren, wie Sie den vollständigen Artikel lesen und auf viele hundert weitere Artikel zugreifen können.

Sind Sie Abonnent?Jetzt einloggen ...
 

Kompletten Artikel lesen?

Einfach für den Newsletter anmelden, dann lesen Sie schon in einer Minute den kompletten Artikel und erhalten die Beispieldatenbanken.

E-Mail:

© 2003-2015 André Minhorst Alle Rechte vorbehalten.