Ribbon anpassen, Teil 1

Das Ribbon, in der deutschen Version von Office auch Menüband genannt, ist die Menüleiste für Office-Anwendungen und somit auch für Access. Sie können die Befehle im Ribbon jedoch nicht nur während der Entwicklung von Access-Anwendungen nutzen, sondern dieses für eigene Anwendungen so anpassen, dass der Benutzer die Funktionen dieser Anwendung darüber aufrufen kann. Dabei können Sie die eingebauten Elemente sogar weitgehend ausblenden, sodass man Ihrer Anwendung nur noch an wenigen Stellen ansieht, dass es sich überhaupt um eine Access-Anwendung handelt. Diese Artikelreihe liefert alle Informationen, die Sie für die Arbeit mit dem Ribbon und für seine Anpassung und Programmierung benötigen. Dabei lernen Sie auch alle Steuerelemente und ihre Eigenschaften kennen.

Beispieldatenbank

Die Beispiele dieses Artikels finden Sie in der Datenbank 2105_RibbonAnpassen.accdb.

Ribbon im Kontext der Access-Benutzeroberfläche

Das Ribbon ist nur ein Element der Benutzeroberfläche, die wir in diesem Artikel beschreiben. Die weiteren Elemente sind:

• der Backstage-Bereich (das ist der Bereich, der erscheint, wenn Sie in Access ab Version 2010 auf den Ribbonreiter Datei klicken)
• die Schnellzugriffsleiste (Quick Access Toolbar, QAT), welche immer sichtbare Schaltfläche anzeigt und in der Regel über dem eigentlichen Ribbon positioniert ist
• die Kontextmenüs (contextMenus), die zum Ausführen von Befehlen dienen, die per Klick mit der rechten Maustaste erscheinen und
• die Commands. Das sind nicht sichtbare Elemente, mit denen Sie die Funktion vorhandener, eingebauter Elemente durch benutzerdefinierte Funktionen ersetzen oder erweitern können.

Aufbau des Ribbons

Wir schauen uns zunächst die Elemente des Ribbons an, die wir auf den ersten Blick sehen (siehe Bild 1). Ganz oben sehen wir die Quick Access Toolbar beispielsweise mit den Schaltflächen zum Speichern, Wiederholen oder Rückgängig machen von Schritten.

Bild 1: Elemente des Ribbons

Der Bereich darunter bis zum Arbeitsbereich von Access ist das Ribbon beziehungsweise das Menüband. Die Hauptelemente im Ribbon sind die tab-Elemente.

Neben diesen gibt es noch sogenannte Contextual Tabs. Diese werden nur im Kontext mit bestimmten Elementen der Benutzeroberfläche eingeblendet, beispielsweise mit der Datenblattansicht von Tabellen, Abfragen oder Formularen.

In der Hierarchie unterhalb der tab-Elemente sind die group-Elemente angeordnet. Jedes tab-Element kann ein oder mehrere group-Elemente enthalten, die jeweils nur mit dem übergeordneten Tab angezeigt werden. Die group-Elemente wiederum enthalten die eigentlichen Steuerelemente – siehe weiter unten. Außerdem finden wir im Ribbon rechts neben den Beschriftungen einiger group-Elemente noch sogenannte dialogBoxLauncher, mit denen Sie Dialoge mit weiteren Optionen zu den Gruppen öffnen können.

Der Bereich Datei/Backstage

Wenn Sie auf den Tab-Reiter Datei klicken, erscheint kein entsprechendes Tab-Element, sondern ein komplett anderer Bereich.

Dieser heißt Backstage-Bereich und enthält einige Schaltflächen und Steuerelemente für allgemeine Funktionen von Access, zum Beispiel zum Öffnen und Schließen von Datenbanken, Drucken oder Anzeigen der Access-Optionen (siehe Bild 2).

Bild 2: Der Backstabe-Bereich

Die Schaltflächen hier können Sie zum Öffnen der dahintersteckenden Bereiche nutzen. Manche rufen auch einfach Funktionen auf, ohne einen eigenen Bereich anzuzeigen.

Steuern des Ribbons

Das Ribbon steuert man gewöhnlich durch Anklicken von Tabs oder Steuerelementen mit der Maus. Sie können aber auch Tastenkombinationen nutzen.

Betätigen Sie die Alt-Taste, erscheinen die in Bild 3 sichtbaren Buchstaben im Ribbon, mit denen Sie die einzelnen Tabs oder Befehle der Schnellzugriffsleiste aufrufen können.

Bild 3: Aktivieren von Ribbonbefehlen per Alt-Taste

Betätigen Sie dann die Taste mit dem jeweiligen Buchstaben, um einen Befehl direkt auszuführen oder das entsprechende tab-Element zu aktivieren und die Tastenkombinationen für die dortigen Befehle anzuzeigen.

Mögliche Anpassungen des Ribbons

Es gibt zwei Möglichkeiten, wie man das Ribbon anpassen kann:

• Anpassung mit Bordmitteln
• Anpassung mit XML

Anpassungen des Ribbons mit Bordmitteln

Die Anpassung mit Bordmitteln bezieht sich immer auf die aktuelle Access-Installation, also nicht etwa auf die aktuelle Datenbankdatei.

Dafür ist eine XML-Anpassung nötig. Die Anpassung mit Bordmitteln erfolgt über zwei Bereiche des Dialogs Access-Optionen, und zwar:

• Menüband anpassen
• Symbolleiste für den Schnellzugriff

Unter Menüband anpassen finden Sie zwei Listen (siehe Bild 4). Die linke zeigt alle Befehle an, die überhaupt für das Ribbon zur Verfügung stehen. Diese können Sie nach verschiedenen Kriterien über das Kombinationsfeld Befehle auswählen filtern.

Bild 4: Bereich des Optionen-Dialogs zum Anpassen des Menübands

Rechts sehen Sie den Bereich Menüband anpassen, der die nach einem Eintrag des oberen Kombinationsfeldes gefilterten Registerkarten anzeigt.

Sie können jeden Befehl zu jedem Bereich des Ribbons hinzufügen, allerdings nur in einer eigenen, benutzerdefinierten Gruppe. Sie nutzen also zuerst die Schaltfläche Neue Gruppe, um eine neue Gruppe hinzuzufügen, und kopieren dann die Befehle per Drag-and-Drop dort hinein.

Sie können auch eine komplett neue Registerkarte hinzufügen (Schaltfläche Neue Registerkarte) oder benutzerdefinierte Elemente über die Schaltfläche Umbenennen… umbenennen. Diese benutzerdefinierten Einträge können Sie mit einem Klick auf die Schaltfläche Zurücksetzen wieder verwerfen. Oder Sie exportieren diese mit einem Klick auf die Schaltfläche Importieren/Exportieren. So können Sie die Änderungen in eine Datei exportieren und diese darüber wieder in eine andere Access-Installation importieren.

Anpassen der Schnellzugriffsleiste

Die Schnellzugriffsleiste passen Sie auf ähnliche Weise an, und zwar im Bereich Symbolleiste für den Schnellzugriff in den Access-Optionen (siehe Bild 5). Der linke Bereich sieht genauso aus wie im zuvor beschriebenen Dialog, der rechte ist etwas einfacher gehalten. Hier können Sie nur einfach Einträge zur Schnellzugriffsleiste hinzufügen, diese hat keine weiteren Hierarchien wie Tabs oder Gruppen.

Bild 5: Bereich des Optionen-Dialogs zum Anpassen der Schnellzugriffsleiste

Anpassungen des Ribbons für die aktuelle Datenbankdatei

Die zweite Möglichkeit der Anpassung des Ribbons bezieht sich nicht auf die Access-In-stallation, sondern auf die aktuell geladene Access-Datenbank.

Auf diese Weise können Sie einer von Ihnen programmierten Datenbank eine Art Menüleiste hinzufügen, mit der Sie oder andere Benutzer mit Schaltflächen die Funktionen der Datenbank starten oder Elemente wie Formulare oder Berichte aufrufen können. Mit weiteren Steuerelementen wie Menüs, Splitbuttons oder dem Gallery-Steuerelement können Sie die Schaltflächen weiter verschachteln.

Oder Sie nutzen Steuerelemente wie comboBox oder dropDown zur Auswahl von Werten, editBox zur Anzeige oder Eingabe von Texten oder auch Umschaltflächen oder Kontrollkästchen für das Anzeigen oder Einstellen von Optionen. Die Anpassungen lassen sich im Wesentlichen für zwei Bereiche definieren:

• die Hauptanwendung
• einzelne Formulare und Berichte

Sie können also eine Ribbondefinition festlegen, die gleich beim Start als Anwendungsribbon angezeigt wird.

Diese Einstellung nehmen Sie in den Access-Optionen im Bereich Aktuelle Datenbank vor (siehe Bild 6).

Bild 6: Option zum Auswählen des Menübands für eine Anwendung

Außerdem können Sie weitere Ribbondefinitionen hinterlegen, die Sie einzelnen Formularen oder Berichten zuweisen. Die entsprechenden Ribbons erscheinen dann, sobald das entsprechende Formular oder der Bericht geöffnet werden oder anderweitig den Fokus erhalten.

Diese Einstellung nehmen Sie für die Eigenschaft Name des Menübands im Bereich Andere des Formularentwurfs vor (siehe Bild 7). Auch hier sehen wir noch keinen Wert, da wir noch keine Ribbondefinition zur Anwendung hinzugefügt haben.

Bild 7: Option zum Auswählen des Menübands für ein Formular

Die gleiche Eigenschaft finden Sie auch für Berichte vor.

Einfache Ribbondefinition erstellen

Damit wir uns in der Praxis ansehen können, wie wir ein Ribbon erstellen und dieses auch als Anwendungsribbon oder als Formular- oder Berichtsribbon anzeigen können, müssen wir eine entsprechende Definition erstellen. Diese formulieren wir im XML-Format.

Genau wie wir oben festgestellt haben, dass das Ribbon nur ein Teil der möglichen Anpassungen der Benutzeroberfläche ist, sieht es auch in der XML-Definition aus. Das Basiselement lautet nämlich customUI und wird wie folgt angelegt:

<xml version="1.0">
<customUI xmlns="http://schemas.microsoft.com/office/2009/07/customui"/>

Diesem fügen wir als Erstes ein ribbon-Element hinzu, weil wir das eigentliche Ribbon anpassen möchten:

<xml version="1.0">
<customUI xmlns="http://schemas.microsoft.com/office/2009/07/customui">
   <ribbon/>
</customUI>

Der nächste Schritt ist ein tab-Element, das allerdings – im Ribbon nicht sichtbar – ein umschließendes tabs-Element benötigt. Dieses fasst alle tab-Elemente ein.

Ein tab-Element muss zumindest das Attribut id aufweisen und sollte auch eine Beschriftung enthalten, hier durch das label-Attribut realisiert:

<xml version="1.0">
<customUI xmlns="http://schemas.microsoft.com/office/2009/07/customui">
   <ribbon>
     <tabs>
       <tab id="tab" label="Beispieltab"/>
     </tabs>
   </ribbon>
</customUI>

Das reicht als Grundstein aus, um die Anpassung vorzunehmen. Dazu sind jedoch noch weitere Schritte nötig.

Tabelle zum Speichern von Ribbondefinitionen

Wir benötigen nämlich eine Tabelle, in der wir alle Ribbondefinitionen für die Anwendung speichern. Diese enthält die folgenden Felder:

• ID: Primärschlüsselfeld der Tabelle
• RibbonName: Bezeichnung, die in den Auswahlfeldern zum Festlegen der Menübänder in den Access-Optionen und den Eigenschaften von Formularen und Berichten angezeigt werden soll
• RibbonXML: Definition des Ribbons im XML-Format

Der Entwurf der Tabelle wird in Bild 8 abgebildet.

Bild 8: Entwurf der Tabelle zum Speichern der Ribbondefinitionen

Diese Tabelle muss zwingend USysRibbons heißen. Wenn wir in die Datenblattansicht wechseln, können wir den soeben entwickelten XML-Code für die Ribbondefinition wie in Bild 9 als ersten Datensatz in die Tabelle einfügen.

Bild 9: Eine erste Ribbondefinition in der Tabelle USysRibbons

Wenn wir nun allerdings versuchen, dieses Ribbon in den Access-Optionen oder als Eigenschaft eines Formulars oder Berichts auszuwählen, gelingt dies noch nicht auf Anhieb.

Dazu ist noch ein wichtiger Schritt notwendig: Wir müssen die Anwendung neu starten und somit die Inhalte der Tabelle USysRibbons einlesen, damit diese in den Auswahlfeldern mit den verfügbaren Ribbondefinitionen erscheinen.

USysRibbons ist eine Systemtabelle

Unter Umständen haben Sie die Tabelle USysRibbons nun gespeichert und geschlossen und wundern sich, dass diese gar nicht im Navigationsbereich erscheint. Das ist der Fall, weil USysRibbons mit USys… beginnt, was benutzerdefinierten Systemtabellen vorbehalten ist. Diese werden von Access standardmäßig nicht angezeigt. Wenn Sie diese bearbeiten wollen, können Sie die Systemtabellen über eine Option einblenden. Dazu klicken Sie mit der rechten Maustaste auf den Titel des Navigationsbereichs und wählen den Kontextmenü-Eintrag Navigationsoptionen… aus.

Es erscheint der Dialog aus Bild 10, in dem Sie die Option Systemobjekte anzeigen aktivieren.

Bild 10: Einblenden der Systemtabellen

Direkt danach erscheint auch die Tabelle USysRibbons im Navigationsbereich, wo Sie diese per Doppelklick zur weiteren Bearbeitung öffnen können.

Wenn Sie die Systemtabellen nicht einblenden möchten, können Sie die Tabelle USysRibbons übrigens auch mit dem folgenden Befehl über den Direktbereich des VBA-Editors öffnen (anzuzeigen mit Strg + G):

DoCmd.OpenTable               "USysRibbons"

Anwendungsribbon einstellen

Nun wollen wir allerdings erstmals unser Ribbon als Anwendungsribbon einstellen. Also schließen wir die Datenbank und öffnen diese erneut, was am schnellsten über den Befehl Datei|Informationen|Datenbank komprimieren und reparieren gelingt.

Danach öffnen wir die Access-Optionen und wechseln dort zum Bereich Aktuelle Datenbank. Unter Menüband- und Symbolleistenoptionen finden wir die Option Name des Menübands, wo wir nun die Definition mit dem Namen aus dem Feld RibbonName der Tabelle USysRibbons auswählen können (siehe Bild 11).

Bild 11: Auswählen des benutzerdefinierten Ribbons als Anwendungsribbon

Damit unsere Anpassung angezeigt wird, benötigen wir allerdings noch einen weiteren Neustart der Datenbankdatei. Danach finden wir die Anpassung wie in Bild 12 im Ribbon vor.

Bild 12: Das neue tab-Element im Ribbon

Das sieht recht unscheinbar aus, und wenn wir den neuen Registerreiter anklicken, erscheint das leere Ribbontab aus Bild 13.

Bild 13: Das neue tab-Element enthält noch keine Gruppen oder Steuerelemente.

Das war allerdings erst der Anfang und wir wollen nun Gruppen und Steuerelemente anfügen.

tab-Element füllen

Als Erstes fügen wir dazu ein group-Element hinzu. Spannenderweise werden zwar die tab-Elemente in ein tabs-Element eingefasst, aber die group-Elemente nicht in ein groups-Element.

Das liegt vermutlich daran, dass es neben dem tabs-Element noch ein weiteres übergeordnetes Element für tab-Elemente namens contextualTabs gibt. Dazu kommen wir später.

group-Element hinzufügen

Das group-Element muss wie alle anderen ein id-Attribut mit einem für diese Ribbondefinition eindeutigen Wert enthalten.

Außerdem benötigen wir eine Beschriftung, die wir wiederum im Attribut label hinterlegen:

<xml version="1.0">
<customUI xmlns="http://schemas.microsoft.com/office/2009/07/customui">
   <ribbon>
     <tabs>
       <tab id="tab" label="Beispieltab">
         <group id="grp" label="Beispielgruppe"/>
       </tab>
     </tabs>
   </ribbon>
</customUI>

button-Element hinzufügen

Im group-Element legen wir auch direkt ein button-Element an, damit wir bei der nächsten Änderung ein Steuerelement in der Gruppe des neuen tab-Elements sehen. Das button-Element innerhalb des group-Elements erhält ebenfalls die beiden Attribute id und label:

<xml version="1.0">
<customUI xmlns="http://schemas.microsoft.com/office/2009/07/customui">
   <ribbon>
     <tabs>
       <tab id="tab" label="Beispieltab">
         <group id="grp" label="Beispielgruppe">
           <button label="Beispielbutton" id="btn"/>
         </group>
       </tab>
     </tabs>
   </ribbon>
</customUI>

Nachdem Sie die Ribbondefinition in der Tabelle USysRibbons wie oben angepasst haben und die Datenbank erneut schließen und wieder öffnen, finden wir das Ribbon wie in Bild 14 vor.

Bild 14: Ribbondefinition mit einer Schaltfläche

Ereignis beim Anklicken der Schaltfläche

Auch wenn die Schaltfläche noch ein Icon vertragen könnte, wollen wir zunächst eine Funktion dafür hinterlegen. Dazu sind einige weitere Schritte nötig.

Als Erstes müssen wir in der Ribbondefinition hinterlegen, dass überhaupt eine Aktion beim Anklicken des button-Elements ausgelöst werden soll.

Dazu fügen wir das Attribut onAction hinzu und legen als Wert den Namen einer VBA-Routine fest, die beim Anklicken der Schaltfläche ausgelöst werden soll, zum Beispiel ebenfalls onAction. Der Code nur für das button-Element lautet nun:

<button label="Beispielbutton" id="btn" onAction="onAction"/>

VBA-Prozedur für das Callback-Attribut

Nun benötigen wir eine entsprechende Prozedur in einem Modul des VBA-Projekts der Datenbankdatei, die beim Anklicken des button-Elements ausgelöst wird. Diese hat eine spezielle Signatur, die wir zwingend verwenden müssen – anderenfalls wird die Routine nicht gefunden. Die Routinen für das Ribbon wollen wir in einem eigenen Modul namens mdlRibbon ablegen. Die Prozedur sieht ohne weitere Anweisungen zunächst wie folgt aus:

Sub onAction(control As IRibbonControl)
End Sub

Fehlender Office-Verweis für Ribbon-Funktionen

Wenn Sie die Anwendung nun kompilieren, erhalten Sie allerdings einen Fehler wie in Bild 15. Der einzige benutzerdefinierte Typ, der hier infrage kommt, heißt IRibbonControl. Warum ist dieser nicht definiert Weil die Elemente zur Programmierung des Ribbons nicht in den Bibliotheken enthalten sind, die standardmäßig in einem VBA-Projekt referenziert werden, sondern in einer Bibliothek, die allen Office-Anwendungen zur Verfügung steht. Das ist logisch, denn auch das Ribbon basiert ja in allen Office-Anwendungen auf der gleichen Technik.

Bild 15: Fehler beim Kompilieren der Anwendung

Der fehlende Verweis heißt Microsoft Office x.0 Object Library und Sie können ihn über den Verweise-Dialog hinzufügen.

Dazu wählen Sie im VBA-Editor den Menüeintrag Extras|Verweise aus. Hier fügen Sie den fehlenden Verweis wie in Bild 16 hinzu. Danach lässt sich die Funktion erfolgreich kompilieren.

Bild 16: Hinzufügen des fehlenden Office-Verweises

Anzeige von Ribbonfehlern aktivieren

Bevor wir die Schaltfläche ausprobieren, wollen wir uns noch um eine weitere Sache kümmern. Die Office-Anwendungen können eine Meldung ausgeben, wenn eine benutzerdefinierte Ribbondefinition Fehler erzeugt.

Dies müssen Sie jedoch zunächst noch aktivieren. Dazu bemühen wir wiederum die Access-Optionen, wo Sie im Bereich Clienteinstellungen unter Allgemein die Option Fehler von Benutzeroberflächen-Add-Ins anzeigen finden und aktivieren (siehe Bild 17).

Bild 17: Aktivieren der Fehleranzeige für Ribbons

Danach zeigt Access beispielsweise eine Fehlermeldung an, wenn die Ribbondefinition fehlerhaft ist – also wenn beispielsweise das schließende Element zu einem Element fehlt oder ein Pflichtattribut nicht enthalten ist.

Test der Ribbon-Schaltfläche

Bevor wir die Schaltfläche ausprobieren, fügen wir der Prozedur onAction noch eine MsgBox-Anweisung hinzu:

Sub onAction(control As IRibbonControl)
     MsgBox "Aufruf von Steuerelement '" & control.Id & "'"
End Sub

Hier setzen wir eine Meldung zusammen, welche die Eigenschaft id des übergebenen Parameters control verwendet. Wie Bild 18 zeigt, liefert dies genau den Namen, den wir für das Attribut id des button-Elements festgelegt haben.

Bild 18: Meldung per button-Steuerelement

Das liefert uns die Möglichkeit, alle Ereignisse, die durch button-Elemente ausgelöst werden, in einer einzigen onAction-Prozedur zu verarbeiten. Wir müssen in dieser lediglich den Wert des Parameters control.id prüfen und beispielsweise in einer Select Case-Bedingung die entsprechenden Anweisungen aufrufen.

Bilder für Schaltflächen

Wenn Sie eine optisch ansprechende Benutzeroberfläche verwenden wollen, können Sie beispielsweise für die button-Elemente des Ribbons Icons anzeigen. Das ist allerdings nicht trivial, denn wir benötigen eine Menge weiteren Code dafür. Außerdem müssen wir eine weitere Tabelle nutzen, die allerdings normalerweise schon in Ihrer Datenbank vorhanden ist. Um ein Bild anzuzeigen, sind die folgenden Schritte nötig:

• Hinzufügen des Bildes zu der Tabelle MSysResources und Merken des Wertes in der Spalte Name
• Hinzufügen des Bildnamen als Wert des Attributs image des button-Elements
• Hinzufügen des Wertes loadImages zum Attribut loadImages des Elements customUI
• Anlegen eines Moduls namens mdlRibbonImages mit speziellen Bildfunktionen
• Hinzufügen einer Prozedur namens LoadImages zum Modul mdlRibbons

Bild zur Tabelle MSysResources hinzufügen

Die Tabelle MSysResources sehen wir erst, wenn wir nicht nur die Option Systemobjekte anzeigen aktiviert haben, sondern auch die Option Ausgeblendete Objekte anzeigen.

Diese finden wir an der gleichen Stelle wie die zuvor erwähnte Option. Anschließend können wir die Tabelle MSysResources über den Navigationsbereich öffnen und dann mit einem Doppelklick auf das @-Symbol eines neuen Datensatzes ein Bild hinzufügen – optimalerweise eines mit der Dateiendung .png. Die Auswahl erledigen wir mit dem nun erscheinenden Dialog Attachments (siehe Bild 19). Hier klicken Sie auf die Schaltfläche Add… und wählen im nächsten Dialog die einzufügende Bilddatei aus.

Bild 19: Hinzufügen einer Bilddatei

Größe des Bildes

Hier taucht nun die Frage auf, welche Größe die als Icon eines Ribbonelements zu verwendenden Bilddateien haben sollen. Es gibt zwei darstellbare Bildgrößen: 16×16 für normale und 32×32 für große Schaltflächen und Steuerelemente.

Am besten fügen Sie immer Bilder mit der Größe 32×32 hinzu, denn die sehen auch bei kleinen Steuerelementen, die Bilder im Format 16×16 anzeigen, gut aus, während Bilder mit der Größe 16×16 bei Verwendung in Steuerelementen mit großen Bildern pixelig aussehen.

Nach der Auswahl des Bildes

Im Dialog Choose File wählen Sie wie in Bild 20 die gewünschte Bilddatei aus.

Bild 20: Auswählen der Bilddatei

Danach erscheint die Bilddatei zunächst im Dialog Attachments (siehe Bild 21).

Bild 21: Die Bilddatei ist im Attachment-Feld gelandet.

Schließen wir den Dialog, finden wir für das @-Symbol in Klammern die Zahl 1 vor. Nun können wir noch die übrigen Felder mit den benötigten Werten füllen. Als Namen legen wir in diesem Fall beispielsweise banana fest, für das Feld Extension den Wert png und für Type den Wert img.

Bilder per Formularansicht hinzufügen

Sie können die Bilder auch noch auf eine etwas einfachere Weise zur Tabelle MSysResources hinzufügen. Dazu verwenden Sie die Entwurfsansicht von Formularen. Hier klicken Sie im Ribbon auf den Eintrag Entwurf|Steuerelemente|Bild einfügen|Durchsuchen… (siehe Bild 22).

Bild 22: Öffnen des Dialogs zum Auswählen einer Bilddatei

Im nun erscheinenden Grafik einfügen-Dialog wählen Sie die gewünschte Bilddatei aus. Danach verwandelt der Mauszeiger sich in ein Symbol zum Einfügen eines Bildes, wenn Sie damit über den Formularentwurf fahren.

Wir wollen das Bild aber nicht in das Formular einfügen, sondern in die Tabelle MSysResources. Aber keine Sorge: Das ist längst geschehen! Sie können den Vorgang mit der Esc-Taste abbrechen.

Klicken Sie danach erneut auf den Ribboneintrag von eben, zeigt dieser das hinzugefügte Icon im Aufklappmenü an (siehe Bild 23).

Bild 23: Das hinzugefügte Icon erscheint in der Auswahlliste für den Formularentwurf.

Und diese Liste bezieht ihre Bilder eben aus der Tabelle USysResources, wo Sie anschließend ebenfalls einen Eintrag für dieses Bild vorfinden (siehe Bild 24).

Bild 24: Das neue Bild in der Tabelle MSysResources

Ribbon-definition für die Anzeige des Bildes anpassen

Nun fügen wir dem Steuerelement, welches das Bild anzeigen soll, das Attribut image hinzu und stellen dieses auf den Wert des Feldes Name für den gewünschten Datensatz der Tabelle MSysResources – in diesem Fall banana:

<button image="banana" label="Beispielbutton" id="btn" onAction="onAction"/>

Außerdem wollen wir ein Callback-Attribut namens loadImage zu diesem Element hinzufügen, mit dem wir die Prozedur angeben, die das für image angegebene Bild in das Ribbon laden soll.

Danach sieht das Element wie folgt aus:

<button image="banana" label="Beispielbutton" id="btn" onAction="onAction" loadImage="loadImage"/>

Dies ist die erste von zwei Möglichkeiten, die andere sehen wir uns gleich im Anschluss an.

Modul mit Bildfunktionen hinzufügen

Für das eigentliche Auslesen der Bilddatei aus dem Anlagefeld benötigen wir einige API-Funktionen, die wir hier nicht im Detail beschreiben können. Sie finden diese jedoch in der Beispieldatenbank unter dem Namen mdlRibbonImages.

Prozedur loadImage erstellen

Die Prozedur loadImage sieht wie in Listing 1 aus. Sie erwartet mit dem Parameter control nicht etwa wie beispielsweise onAction einen Verweis auf das Steuerelement, für das diese Prozedur aufgerufen wird, sondern den Wert der Eigenschaft image – hier also der Wert banana. Der zweite Parameter gibt das Bild mit dem Datentyp StdPicture an das aufrufende Ribbon zurück.

Public Sub loadImage(imageId, ByRef image)
     Dim lngID As Long
     On Error Resume Next
     lngID = Nz(DLookup("ID", "MSysResources", "Name = '" & control & "'"), 0)
     If Err.Number = 3078 Then
         MsgBox "Die Tabelle 'MSysResources' mit den Images für die Anzeige im Ribbon fehlt.", vbOKOnly + vbExclamation, _
             "Tabelle MSysResources fehlt"
         Exit Sub
     End If
     On Error GoTo 0
     If lngID = 0 Then
         MsgBox "Das Image '" & control & "' ist nicht in der Tabelle MSysResources vorhanden. " & vbCrLf _
             & "Fügen Sie dieses hinzu, indem Sie im Formularentwurf die Funktion zum Einfügen von Bildern nutzen," _
             & "ohne das Bild zum Formular selbst hinzuzufügen."
     Else
         Set image = PicFromSharedResource_Ribbon(CStr(control))
     End If
End Sub

Listing 1: Die Prozedur loadImage

Jetzt könnte ein Fragezeichen auftauchen: Warum legen wir image im jeweiligen Steuerelement fest und loadImage im Element CustomUI Das ist eine Ausnahme im Vergleich zu einigen anderen Callback-Attributen, die wir später noch kennenlernen werden. Die Prozedur loadImage wird nämlich beim Laden der Ribbondefinition für jedes Steuerelement mit dem Attribut image einmal aufgerufen. Deshalb wird dann auch für control der Wert des Attributs image des jeweiligen Steuerelement übergeben und nicht der Verweis auf das customUI-Element.

Die Prozedur, die wir für das Attribut load-Image hinterlegt haben, prüft erst einmal, ob die Tabelle MSysResources überhaupt einen Datensatz enthält, der im Feld Name den Wert aus dem Parameter control enthält. Falls dies einen Fehler 3078 auslöst, ist die Tabelle MSysResources gar nicht vorhanden. In diesem Fall liefert die Prozedur eine entsprechende Fehlermeldung.

Anderenfalls kann es sein, dass das gesuchte Bild nicht gefunden wurde. Auch in diesem Fall liefert die Prozedur eine Meldung. Ist das Bild jedoch vorhanden, was in der Regel der Fall sein sollte, ruft sie die Funktion PicFromSharedResource_Ribbon auf und übergibt den Namen des einzulesenden Bildes. Dieses wird dann als Objekt des Typs StdPicture zurückgeliefert und im Ribbon angezeigt (siehe Bild 25).

Bild 25: Das Bild einer Ribbonschaltfläche

Alternative getImage

Weiter oben haben wir das Attribut loadImage des Elements customUI in Kombination mit dem Element image des jeweiligen Steuerelements zum Laden eines Bildes genutzt. Es gibt auch noch das Callbackattribut getImage. Dieses hinterlegen Sie für das Steuerelement, für das Sie ein Bild laden wollen. Die Callback-Signatur dieser Prozedur sieht wie folgt aus:

Sub getImage(control As IRibbonControl, ByRef image)
     
End Sub

Im Gegensatz zu loadImage wird der Parameter control hier nicht als Variant übergeben, sondern wieder als Element des Typs IRibbonControl. Der zweite Parameter erwartet das anzuzeigende Bild als StdPicture. Das heißt also, dass wir hier nicht den Wert des Attributs image erhalten. Also haben wir in dieser Prozedur keine Information darüber, welches Bild geladen werden soll. Wir könnten das schematisch wie folgt regeln:

Sub getImage(control As IRibbonControl, ByRef image)
     Select Case control.id
         Case "btnBeispielbutton"
             Set image =                  PicFromSharedResource_Ribbon("banana")
         Case ...
     End Select
End Sub

Wir würden also prüfen, welchen Namen das Steuerelement hat und dann das zu verwendende Bild, hier wieder banana, fest im Code verankern. Das hat aber den Nachteil, dass wir zum Ändern des Bildes nicht mehr die Ribbondefinition, sondern den Code anpassen müssten – was keine gute Idee ist.

Speichern des Bildes im tag-Attribut

Also nutzen wir ein noch nicht verwendetes Attribut eines Steuerelements, nämlich tag. Den Wert des tag-Attributs können wir ebenfalls über die Eigenschaften des IRibbonControl-Elements auslesen. Daraus können wir dann aus der oben verwendeten loadImage-Prozedur eine getImage-Prozedur ableiten (siehe Listing 2).

Sub getImage(control As IRibbonControl, ByRef image)
     Dim lngID As Long
     If Len(control.Tag) = 0 Then
         MsgBox "Es wurde kein Bildname für das Attribut 'tag' im Element '" & control.id & "' hinterlegt.", vbOKOnly + vbExclamation
         Exit Sub
     End If
     On Error Resume Next
     lngID = Nz(DLookup("ID", "MSysResources", "Name = '" & control.Tag & "'"), 0)
     If Err.Number = 3078 Then
         MsgBox "Die Tabelle 'MSysResources' mit den Images für die Anzeige im Ribbon fehlt.", vbOKOnly + vbExclamation, _
             "Tabelle MSysResources fehlt"
         Exit Sub
     End If
     On Error GoTo 0
     If lngID = 0 Then
         MsgBox "Das Image '" & control & "' ist nicht in der Tabelle MSysResources vorhanden. " & vbCrLf _
             & "Fügen Sie dieses hinzu, indem Sie im Formularentwurf die Funktion zum Einfügen von Bildern nutzen," _
             & "ohne das Bild zum Formular selbst hinzuzufügen."
     Else
         Set image = PicFromSharedResource_Ribbon(CStr(control.Tag))
     End If
End Sub

Listing 2: Die Prozedur getImage

Diese wertet zunächst den Inhalt der Tag-Eigenschaft des mit control übergebenen IRibbonControl-Elements aus. Dieses füllen wir für dieses Element wie folgt – der Name des Images wird also im tag-Attribut gespeichert:

<button label="Beispielbutton1" id="btn1" onAction="onAction" getImage="getImage" tag="close"/>

Ist die Eigenschaft Tag leer, liefert die Prozedur eine entsprechende Meldung. Der Rest funktioniert wie in der Prozedur LoadImage, die wir weiter oben beschrieben haben.

Unterschied zwischen loadImage und getImage

Benutzername oder E-Mail-Adresse: