Aufbau des Ribbons<\/h2>\n
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.<\/p>\n
Bild 1: Elemente des Ribbons<\/p>\n Der Bereich darunter bis zum Arbeitsbereich von Access ist das Ribbon beziehungsweise das Menüband. Die Hauptelemente im Ribbon sind die tab<\/b>-Elemente.<\/p>\n 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.<\/p>\n In der Hierarchie unterhalb der tab<\/b>-Elemente sind die group<\/b>-Elemente angeordnet. Jedes tab<\/b>-Element kann ein oder mehrere group<\/b>-Elemente enthalten, die jeweils nur mit dem übergeordneten Tab angezeigt werden. Die group<\/b>-Elemente wiederum enthalten die eigentlichen Steuerelemente – siehe weiter unten. Außerdem finden wir im Ribbon rechts neben den Beschriftungen einiger group<\/b>-Elemente noch sogenannte dialogBoxLauncher<\/b>, mit denen Sie Dialoge mit weiteren Optionen zu den Gruppen öffnen können.<\/p>\n Wenn Sie auf den Tab-Reiter Datei <\/b>klicken, erscheint kein entsprechendes Tab<\/b>-Element, sondern ein komplett anderer Bereich.<\/p>\n Dieser heißt Backstage<\/b>-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).<\/p>\n Bild 2: Der Backstabe-Bereich<\/p>\n Die Schaltflächen hier können Sie zum Öffnen der dahintersteckenden Bereiche nutzen. Manche rufen auch einfach Funktionen auf, ohne einen eigenen Bereich anzuzeigen.<\/p>\n Das Ribbon steuert man gewöhnlich durch Anklicken von Tabs oder Steuerelementen mit der Maus. Sie können aber auch Tastenkombinationen nutzen.<\/p>\n Betätigen Sie die Alt<\/b>-Taste, erscheinen die in Bild 3 sichtbaren Buchstaben im Ribbon, mit denen Sie die einzelnen Tabs oder Befehle der Schnellzugriffsleiste aufrufen können.<\/p>\n Bild 3: Aktivieren von Ribbonbefehlen per Alt-Taste<\/p>\n Betätigen Sie dann die Taste mit dem jeweiligen Buchstaben, um einen Befehl direkt auszuführen oder das entsprechende tab<\/b>-Element zu aktivieren und die Tastenkombinationen für die dortigen Befehle anzuzeigen.<\/p>\n Es gibt zwei Möglichkeiten, wie man das Ribbon anpassen kann:<\/p>\n Die Anpassung mit Bordmitteln bezieht sich immer auf die aktuelle Access-Installation, also nicht etwa auf die aktuelle Datenbankdatei.<\/p>\n Dafür ist eine XML-Anpassung nötig. Die Anpassung mit Bordmitteln erfolgt über zwei Bereiche des Dialogs Access-Optionen<\/b>, und zwar:<\/p>\n 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 <\/b>filtern.<\/p>\n Bild 4: Bereich des Optionen-Dialogs zum Anpassen des Menübands<\/p>\n Rechts sehen Sie den Bereich Menüband anpassen, der die nach einem Eintrag des oberen Kombinationsfeldes gefilterten Registerkarten anzeigt.<\/p>\n 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<\/b>, um eine neue Gruppe hinzuzufügen, und kopieren dann die Befehle per Drag-and-Drop dort hinein.<\/p>\n Sie können auch eine komplett neue Registerkarte hinzufügen (Schaltfläche Neue Registerkarte<\/b>) oder benutzerdefinierte Elemente über die Schaltfläche Umbenennen… <\/b>umbenennen. Diese benutzerdefinierten Einträge können Sie mit einem Klick auf die Schaltfläche Zurücksetzen <\/b>wieder verwerfen. Oder Sie exportieren diese mit einem Klick auf die Schaltfläche Importieren\/Exportieren<\/b>. So können Sie die Änderungen in eine Datei exportieren und diese darüber wieder in eine andere Access-Installation importieren.<\/p>\n Die Schnellzugriffsleiste passen Sie auf ähnliche Weise an, und zwar im Bereich Symbolleiste für den Schnellzugriff <\/b>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.<\/p>\n Bild 5: Bereich des Optionen-Dialogs zum Anpassen der Schnellzugriffsleiste<\/p>\n Die zweite Möglichkeit der Anpassung des Ribbons bezieht sich nicht auf die Access-In-stallation, sondern auf die aktuell geladene Access-Datenbank.<\/p>\n 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.<\/p>\n Oder Sie nutzen Steuerelemente wie comboBox <\/b>oder dropDown <\/b>zur Auswahl von Werten, editBox <\/b>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:<\/p>\n Sie können also eine Ribbondefinition festlegen, die gleich beim Start als Anwendungsribbon angezeigt wird.<\/p>\n Diese Einstellung nehmen Sie in den Access-Optionen im Bereich Aktuelle Datenbank <\/b>vor (siehe Bild 6). <\/p>\n Bild 6: Option zum Auswählen des Menübands für eine Anwendung<\/p>\n 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.<\/p>\n Diese Einstellung nehmen Sie für die Eigenschaft Name des Menübands <\/b>im Bereich Andere <\/b>des Formularentwurfs vor (siehe Bild 7). Auch hier sehen wir noch keinen Wert, da wir noch keine Ribbondefinition zur Anwendung hinzugefügt haben.<\/p>\n Bild 7: Option zum Auswählen des Menübands für ein Formular<\/p>\n Die gleiche Eigenschaft finden Sie auch für Berichte vor.<\/p>\n 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.<\/p>\n 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<\/b> und wird wie folgt angelegt:<\/p>\n Diesem fügen wir als Erstes ein ribbon<\/b>-Element hinzu, weil wir das eigentliche Ribbon anpassen möchten:<\/p>\n Der nächste Schritt ist ein tab<\/b>-Element, das allerdings – im Ribbon nicht sichtbar – ein umschließendes tabs<\/b>-Element benötigt. Dieses fasst alle tab<\/b>-Elemente ein.<\/p>\n Ein tab<\/b>-Element muss zumindest das Attribut id <\/b>aufweisen und sollte auch eine Beschriftung enthalten, hier durch das label<\/b>-Attribut realisiert:<\/p>\n Das reicht als Grundstein aus, um die Anpassung vorzunehmen. Dazu sind jedoch noch weitere Schritte nötig.<\/p>\n Wir benötigen nämlich eine Tabelle, in der wir alle Ribbondefinitionen für die Anwendung speichern. Diese enthält die folgenden Felder:<\/p>\n Der Entwurf der Tabelle wird in Bild 8 abgebildet.<\/p>\n Bild 8: Entwurf der Tabelle zum Speichern der Ribbondefinitionen<\/p>\n Diese Tabelle muss zwingend USysRibbons <\/b>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.<\/p>\n Bild 9: Eine erste Ribbondefinition in der Tabelle USysRibbons<\/p>\n 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.<\/p>\n Dazu ist noch ein wichtiger Schritt notwendig: Wir müssen die Anwendung neu starten und somit die Inhalte der Tabelle USysRibbons <\/b>einlesen, damit diese in den Auswahlfeldern mit den verfügbaren Ribbondefinitionen erscheinen.<\/p>\n Unter Umständen haben Sie die Tabelle USysRibbons <\/b>nun gespeichert und geschlossen und wundern sich, dass diese gar nicht im Navigationsbereich erscheint. Das ist der Fall, weil USysRibbons <\/b>mit USys… <\/b>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… <\/b>aus.<\/p>\n Es erscheint der Dialog aus Bild 10, in dem Sie die Option Systemobjekte anzeigen <\/b>aktivieren.<\/p>\n Bild 10: Einblenden der Systemtabellen<\/p>\n Direkt danach erscheint auch die Tabelle USysRibbons <\/b>im Navigationsbereich, wo Sie diese per Doppelklick zur weiteren Bearbeitung öffnen können.<\/p>\n Wenn Sie die Systemtabellen nicht einblenden möchten, können Sie die Tabelle USysRibbons <\/b>übrigens auch mit dem folgenden Befehl über den Direktbereich des VBA-Editors öffnen (anzuzeigen mit Strg + G<\/b>):<\/p>\n 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 <\/b>gelingt.<\/p>\n Danach öffnen wir die Access-Optionen und wechseln dort zum Bereich Aktuelle Datenbank<\/b>. Unter Menüband- und Symbolleistenoptionen <\/b>finden wir die Option Name des Menübands<\/b>, wo wir nun die Definition mit dem Namen aus dem Feld RibbonName <\/b>der Tabelle USysRibbons <\/b>auswählen können (siehe Bild 11).<\/p>\n Bild 11: Auswählen des benutzerdefinierten Ribbons als Anwendungsribbon<\/p>\n 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.<\/p>\n Bild 12: Das neue tab-Element im Ribbon<\/p>\n Das sieht recht unscheinbar aus, und wenn wir den neuen Registerreiter anklicken, erscheint das leere Ribbontab aus Bild 13.<\/p>\n Bild 13: Das neue tab-Element enthält noch keine Gruppen oder Steuerelemente.<\/p>\n Das war allerdings erst der Anfang und wir wollen nun Gruppen und Steuerelemente anfügen.<\/p>\n Als Erstes fügen wir dazu ein group<\/b>-Element hinzu. Spannenderweise werden zwar die tab<\/b>-Elemente in ein tabs<\/b>-Element eingefasst, aber die group<\/b>-Elemente nicht in ein groups<\/b>-Element.<\/p>\n Das liegt vermutlich daran, dass es neben dem tabs<\/b>-Element noch ein weiteres übergeordnetes Element für tab<\/b>-Elemente namens contextualTabs <\/b>gibt. Dazu kommen wir später.<\/p>\n Das group<\/b>-Element muss wie alle anderen ein id<\/b>-Attribut mit einem für diese Ribbondefinition eindeutigen Wert enthalten.<\/p>\n Außerdem benötigen wir eine Beschriftung, die wir wiederum im Attribut label <\/b>hinterlegen:<\/p>\n Im group<\/b>-Element legen wir auch direkt ein button<\/b>-Element an, damit wir bei der nächsten Änderung ein Steuerelement in der Gruppe des neuen tab<\/b>-Elements sehen. Das button<\/b>-Element innerhalb des group<\/b>-Elements erhält ebenfalls die beiden Attribute id <\/b>und label<\/b>:<\/p>\n Nachdem Sie die Ribbondefinition in der Tabelle USysRibbons <\/b>wie oben angepasst haben und die Datenbank erneut schließen und wieder öffnen, finden wir das Ribbon wie in Bild 14 vor.<\/p>\n Bild 14: Ribbondefinition mit einer Schaltfläche<\/p>\n 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.<\/p>\n Als Erstes müssen wir in der Ribbondefinition hinterlegen, dass überhaupt eine Aktion beim Anklicken des button<\/b>-Elements ausgelöst werden soll.<\/p>\n Dazu fügen wir das Attribut onAction <\/b>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<\/b>. Der Code nur für das button<\/b>-Element lautet nun:<\/p>\n Nun benötigen wir eine entsprechende Prozedur in einem Modul des VBA-Projekts der Datenbankdatei, die beim Anklicken des button<\/b>-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<\/b> ablegen. Die Prozedur sieht ohne weitere Anweisungen zunächst wie folgt aus:<\/p>\n 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<\/b>. 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.<\/p>\n Bild 15: Fehler beim Kompilieren der Anwendung<\/p>\n Der fehlende Verweis heißt Microsoft Office x.0 Object Library <\/b>und Sie können ihn über den Verweise<\/b>-Dialog hinzufügen.<\/p>\n Dazu wählen Sie im VBA-Editor den Menüeintrag Extras|Verweise <\/b>aus. Hier fügen Sie den fehlenden Verweis wie in Bild 16 hinzu. Danach lässt sich die Funktion erfolgreich kompilieren.<\/p>\n Bild 16: Hinzufügen des fehlenden Office-Verweises<\/p>\n 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.<\/p>\n Dies müssen Sie jedoch zunächst noch aktivieren. Dazu bemühen wir wiederum die Access-Optionen, wo Sie im Bereich Clienteinstellungen <\/b>unter Allgemein <\/b>die Option Fehler von Benutzeroberflächen-Add-Ins anzeigen <\/b>finden und aktivieren (siehe Bild 17).<\/p>\n Bild 17: Aktivieren der Fehleranzeige für Ribbons<\/p>\n 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.<\/p>\n Bevor wir die Schaltfläche ausprobieren, fügen wir der Prozedur onAction <\/b>noch eine MsgBox<\/b>-Anweisung hinzu:<\/p>\n Hier setzen wir eine Meldung zusammen, welche die Eigenschaft id <\/b>des übergebenen Parameters control <\/b>verwendet. Wie Bild 18 zeigt, liefert dies genau den Namen, den wir für das Attribut id <\/b>des button<\/b>-Elements festgelegt haben.<\/p>\n Bild 18: Meldung per button-Steuerelement<\/p>\n Das liefert uns die Möglichkeit, alle Ereignisse, die durch button<\/b>-Elemente ausgelöst werden, in einer einzigen onAction<\/b>-Prozedur zu verarbeiten. Wir müssen in dieser lediglich den Wert des Parameters control.id <\/b>prüfen und beispielsweise in einer Select Case<\/b>-Bedingung die entsprechenden Anweisungen aufrufen.<\/p>\n Wenn Sie eine optisch ansprechende Benutzeroberfläche verwenden wollen, können Sie beispielsweise für die button<\/b>-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:<\/p>\n Die Tabelle MSysResources <\/b>sehen wir erst, wenn wir nicht nur die Option Systemobjekte anzeigen <\/b>aktiviert haben, sondern auch die Option Ausgeblendete Objekte anzeigen<\/b>.<\/p>\n Diese finden wir an der gleichen Stelle wie die zuvor erwähnte Option. Anschließend können wir die Tabelle MSysResources <\/b>ü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<\/b>. Die Auswahl erledigen wir mit dem nun erscheinenden Dialog Attachments<\/b> (siehe Bild 19). Hier klicken Sie auf die Schaltfläche Add… <\/b>und wählen im nächsten Dialog die einzufügende Bilddatei aus.<\/p>\n Bild 19: Hinzufügen einer Bilddatei<\/p>\n 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.<\/p>\n 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.<\/p>\n Im Dialog Choose File <\/b>wählen Sie wie in Bild 20 die gewünschte Bilddatei aus.<\/p>\n Bild 20: Auswählen der Bilddatei<\/p>\n Danach erscheint die Bilddatei zunächst im Dialog Attachments <\/b>(siehe Bild 21).<\/p>\n Bild 21: Die Bilddatei ist im Attachment-Feld gelandet.<\/p>\n Schließen wir den Dialog, finden wir für das @-<\/b>Symbol in Klammern die Zahl 1 <\/b>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 <\/b>fest, für das Feld Extension <\/b>den Wert png <\/b>und für Type <\/b>den Wert img<\/b>.<\/p>\n Sie können die Bilder auch noch auf eine etwas einfachere Weise zur Tabelle MSysResources <\/b>hinzufügen. Dazu verwenden Sie die Entwurfsansicht von Formularen. Hier klicken Sie im Ribbon auf den Eintrag Entwurf|Steuerelemente|Bild einfügen|Durchsuchen… <\/b>(siehe Bild 22).<\/p>\n Bild 22: Öffnen des Dialogs zum Auswählen einer Bilddatei<\/p>\n Im nun erscheinenden Grafik einfügen<\/b>-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.<\/p>\n Wir wollen das Bild aber nicht in das Formular einfügen, sondern in die Tabelle MSysResources<\/b>. Aber keine Sorge: Das ist längst geschehen! Sie können den Vorgang mit der Esc<\/b>-Taste abbrechen.<\/p>\n Klicken Sie danach erneut auf den Ribboneintrag von eben, zeigt dieser das hinzugefügte Icon im Aufklappmenü an (siehe Bild 23).<\/p>\n Bild 23: Das hinzugefügte Icon erscheint in der Auswahlliste für den Formularentwurf.<\/p>\n Und diese Liste bezieht ihre Bilder eben aus der Tabelle USysResources<\/b>, wo Sie anschließend ebenfalls einen Eintrag für dieses Bild vorfinden (siehe Bild 24).<\/p>\n Bild 24: Das neue Bild in der Tabelle MSysResources<\/p>\n Nun fügen wir dem Steuerelement, welches das Bild anzeigen soll, das Attribut image <\/b>hinzu und stellen dieses auf den Wert des Feldes Name <\/b>für den gewünschten Datensatz der Tabelle MSysResources <\/b>– in diesem Fall banana<\/b>:<\/p>\n Außerdem wollen wir ein Callback-Attribut namens loadImage <\/b>zu diesem Element hinzufügen, mit dem wir die Prozedur angeben, die das für image <\/b>angegebene Bild in das Ribbon laden soll.<\/p>\n Danach sieht das Element wie folgt aus:<\/p>\n Dies ist die erste von zwei Möglichkeiten, die andere sehen wir uns gleich im Anschluss an.<\/p>\n 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<\/b>.<\/p>\n Die Prozedur loadImage<\/b> sieht wie in Listing 1 aus. Sie erwartet mit dem Parameter control <\/b>nicht etwa wie beispielsweise onAction <\/b>einen Verweis auf das Steuerelement, für das diese Prozedur aufgerufen wird, sondern den Wert der Eigenschaft image <\/b>– hier also der Wert banana<\/b>. Der zweite Parameter gibt das Bild mit dem Datentyp StdPicture <\/b>an das aufrufende Ribbon zurück.<\/p>\n Listing 1: Die Prozedur loadImage<\/p>\n Jetzt könnte ein Fragezeichen auftauchen: Warum legen wir image <\/b>im jeweiligen Steuerelement fest und loadImage <\/b>im Element CustomUI<\/b> Das ist eine Ausnahme im Vergleich zu einigen anderen Callback-Attributen, die wir später noch kennenlernen werden. Die Prozedur loadImage <\/b>wird nämlich beim Laden der Ribbondefinition für jedes Steuerelement mit dem Attribut image <\/b>einmal aufgerufen. Deshalb wird dann auch für control<\/b> der Wert des Attributs image <\/b>des jeweiligen Steuerelement übergeben und nicht der Verweis auf das customUI<\/b>-Element.<\/p>\n Die Prozedur, die wir für das Attribut load-Image <\/b>hinterlegt haben, prüft erst einmal, ob die Tabelle MSysResources<\/b> überhaupt einen Datensatz enthält, der im Feld Name <\/b>den Wert aus dem Parameter control <\/b>enthält. Falls dies einen Fehler 3078 <\/b>auslöst, ist die Tabelle MSysResources <\/b>gar nicht vorhanden. In diesem Fall liefert die Prozedur eine entsprechende Fehlermeldung.<\/p>\n 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 <\/b>auf und übergibt den Namen des einzulesenden Bildes. Dieses wird dann als Objekt des Typs StdPicture <\/b>zurückgeliefert und im Ribbon angezeigt (siehe Bild 25).<\/p>\n Bild 25: Das Bild einer Ribbonschaltfläche<\/p>\n Weiter oben haben wir das Attribut loadImage <\/b>des Elements customUI <\/b>in Kombination mit dem Element image <\/b>des jeweiligen Steuerelements zum Laden eines Bildes genutzt. Es gibt auch noch das Callbackattribut getImage<\/b>. Dieses hinterlegen Sie für das Steuerelement, für das Sie ein Bild laden wollen. Die Callback-Signatur dieser Prozedur sieht wie folgt aus:<\/p>\n Im Gegensatz zu loadImage <\/b>wird der Parameter control <\/b>hier nicht als Variant übergeben, sondern wieder als Element des Typs IRibbonControl<\/b>. Der zweite Parameter erwartet das anzuzeigende Bild als StdPicture<\/b>. Das heißt also, dass wir hier nicht den Wert des Attributs image <\/b>erhalten. Also haben wir in dieser Prozedur keine Information darüber, welches Bild geladen werden soll. Wir könnten das schematisch wie folgt regeln:<\/p>\n Wir würden also prüfen, welchen Namen das Steuerelement hat und dann das zu verwendende Bild, hier wieder banana<\/b>, 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.<\/p>\n Also nutzen wir ein noch nicht verwendetes Attribut eines Steuerelements, nämlich tag<\/b>. Den Wert des tag<\/b>-Attributs können wir ebenfalls über die Eigenschaften des IRibbonControl<\/b>-Elements auslesen. Daraus können wir dann aus der oben verwendeten loadImage<\/b>-Prozedur eine getImage<\/b>-Prozedur ableiten (siehe Listing 2).<\/p>\n Listing 2: Die Prozedur getImage<\/p>\n Diese wertet zunächst den Inhalt der Tag<\/b>-Eigenschaft des mit control <\/b>übergebenen IRibbonControl<\/b>-Elements aus. Dieses füllen wir für dieses Element wie folgt – der Name des Images wird also im tag<\/b>-Attribut gespeichert:<\/p>\n Ist die Eigenschaft Tag <\/b>leer, liefert die Prozedur eine entsprechende Meldung. Der Rest funktioniert wie in der Prozedur LoadImage<\/b>, die wir weiter oben beschrieben haben.<\/p>\n Möchten Sie weiterlesen? Dann lösen Sie Ihr Ticket!<\/span>![\"Elemente](\"..\/tl_files\/images\/pic_542_001.png\")
<\/a><\/p>\nDer Bereich Datei\/Backstage<\/h2>\n
<\/a><\/p>\nSteuern des Ribbons<\/h2>\n
<\/a><\/p>\nMögliche Anpassungen des Ribbons<\/h2>\n
\n
Anpassungen des Ribbons mit Bordmitteln<\/h2>\n
\n
<\/a><\/p>\nAnpassen der Schnellzugriffsleiste<\/h2>\n
<\/a><\/p>\nAnpassungen des Ribbons für die aktuelle Datenbankdatei<\/h2>\n
\n
<\/a><\/p>\n<\/a><\/p>\nEinfache Ribbondefinition erstellen<\/h2>\n
<xml version=\"1.0\">\r\n<customUI xmlns=\"http:\/\/schemas.microsoft.com\/office\/2009\/07\/customui\"\/><\/pre>\n
<xml version=\"1.0\">\r\n<customUI xmlns=\"http:\/\/schemas.microsoft.com\/office\/2009\/07\/customui\">\r\n <ribbon\/>\r\n<\/customUI><\/pre>\n
<xml version=\"1.0\">\r\n<customUI xmlns=\"http:\/\/schemas.microsoft.com\/office\/2009\/07\/customui\">\r\n <ribbon>\r\n <tabs>\r\n <tab id=\"tab\" label=\"Beispieltab\"\/>\r\n <\/tabs>\r\n <\/ribbon>\r\n<\/customUI><\/pre>\n
Tabelle zum Speichern von Ribbondefinitionen<\/h2>\n
\n
<\/a><\/p>\n<\/a><\/p>\nUSysRibbons ist eine Systemtabelle<\/h2>\n
<\/a><\/p>\nDoCmd.OpenTable \"USysRibbons\"<\/pre>\n
Anwendungsribbon einstellen<\/h2>\n
<\/a><\/p>\n<\/a><\/p>\n<\/a><\/p>\ntab-Element füllen<\/h2>\n
group-Element hinzufügen<\/h2>\n
<xml version=\"1.0\">\r\n<customUI xmlns=\"http:\/\/schemas.microsoft.com\/office\/2009\/07\/customui\">\r\n <ribbon>\r\n <tabs>\r\n <tab id=\"tab\" label=\"Beispieltab\">\r\n <group id=\"grp\" label=\"Beispielgruppe\"\/>\r\n <\/tab>\r\n <\/tabs>\r\n <\/ribbon>\r\n<\/customUI><\/pre>\n
button-Element hinzufügen<\/h2>\n
<xml version=\"1.0\">\r\n<customUI xmlns=\"http:\/\/schemas.microsoft.com\/office\/2009\/07\/customui\">\r\n <ribbon>\r\n <tabs>\r\n <tab id=\"tab\" label=\"Beispieltab\">\r\n <group id=\"grp\" label=\"Beispielgruppe\">\r\n <button label=\"Beispielbutton\" id=\"btn\"\/>\r\n <\/group>\r\n <\/tab>\r\n <\/tabs>\r\n <\/ribbon>\r\n<\/customUI><\/pre>\n
<\/a><\/p>\nEreignis beim Anklicken der Schaltfläche<\/h2>\n
<button label=\"Beispielbutton\" id=\"btn\" onAction=\"onAction\"\/><\/pre>\n
VBA-Prozedur für das Callback-Attribut<\/h2>\n
Sub <\/span>onAction(control As <\/span><\/span>IRibbonControl)\r\nEnd Sub<\/span><\/pre>\nFehlender Office-Verweis für Ribbon-Funktionen<\/h2>\n
<\/a><\/p>\n<\/a><\/p>\nAnzeige von Ribbonfehlern aktivieren<\/h2>\n
<\/a><\/p>\nTest der Ribbon-Schaltfläche<\/h2>\n
Sub <\/span>onAction(control As <\/span><\/span>IRibbonControl)\r\n MsgBox<\/span> \"Aufruf von Steuerelement '\" & control.Id & \"'\"\r\nEnd Sub<\/span><\/pre>\n<\/a><\/p>\nBilder für Schaltflächen<\/h2>\n
\n
Bild zur Tabelle MSysResources hinzufügen<\/h2>\n
<\/a><\/p>\nGröße des Bildes<\/h2>\n
Nach der Auswahl des Bildes<\/h2>\n
<\/a><\/p>\n<\/a><\/p>\nBilder per Formularansicht hinzufügen<\/h2>\n
<\/a><\/p>\n<\/a><\/p>\n<\/a><\/p>\nRibbon-definition für die Anzeige des Bildes anpassen<\/h2>\n
<button image=\"banana\" label=\"Beispielbutton\" id=\"btn\" onAction=\"onAction\"\/><\/pre>\n
<button image=\"banana\" label=\"Beispielbutton\" id=\"btn\" onAction=\"onAction\" loadImage=\"loadImage\"\/><\/pre>\n
Modul mit Bildfunktionen hinzufügen<\/h2>\n
Prozedur loadImage erstellen<\/h2>\n
Public Sub <\/span>loadImage(imageId, ByRef image)\r\n Dim <\/span>lngID As Long<\/span>\r\n On Error Resume Next<\/span>\r\n lngID = Nz(DLookup(\"ID\", \"MSysResources\", \"Name = '\" & control & \"'\"), 0)\r\n If <\/span>Err.Number = 3078 Then<\/span>\r\n MsgBox<\/span> \"Die Tabelle 'MSysResources' mit den Images für die Anzeige im Ribbon fehlt.\", vbOKOnly + vbExclamation, _\r\n \"Tabelle MSysResources fehlt\"\r\n Exit Sub<\/span>\r\n End If<\/span>\r\n On Error GoTo<\/span> 0\r\n If <\/span>lngID = 0 Then<\/span>\r\n MsgBox<\/span> \"Das Image '\" & control & \"' ist nicht in der Tabelle MSysResources vorhanden. \" & vbCrLf<\/span> _\r\n & \"Fügen Sie dieses hinzu, indem Sie im Formularentwurf die Funktion zum Einfügen von Bildern nutzen,\" _\r\n & \"ohne das Bild zum Formular selbst hinzuzufügen.\"\r\n Else<\/span>\r\n Set<\/span> image = PicFromSharedResource_Ribbon(CStr(control))\r\n End If<\/span>\r\nEnd Sub<\/span><\/pre>\n<\/a><\/p>\nAlternative getImage<\/b><\/h2>\n
Sub <\/span>getImage(control As <\/span><\/span>IRibbonControl, ByRef image)\r\n \r\nEnd Sub<\/span><\/pre>\nSub <\/span>getImage(control As <\/span><\/span>IRibbonControl, ByRef image)\r\n Select Case control.id\r\n Case <\/span>\"btnBeispielbutton\"\r\n Set<\/span> image = PicFromSharedResource_Ribbon(\"banana\")\r\n Case <\/span>...\r\n End Select<\/span>\r\nEnd Sub<\/span><\/pre>\nSpeichern des Bildes im tag-Attribut<\/h2>\n
Sub <\/span>getImage(control As <\/span>IRibbonControl, ByRef image)\r\n Dim <\/span>lngID As Long<\/span>\r\n If <\/span>Len<\/span>(control.Tag) = 0 Then<\/span>\r\n MsgBox<\/span> \"Es wurde kein Bildname für das Attribut 'tag' im Element '\" & control.id & \"' hinterlegt.\", vbOKOnly + vbExclamation\r\n Exit Sub<\/span>\r\n End If<\/span>\r\n On Error Resume Next<\/span>\r\n lngID = Nz(DLookup(\"ID\", \"MSysResources\", \"Name = '\" & control.Tag & \"'\"), 0)\r\n If <\/span>Err.Number = 3078 Then<\/span>\r\n MsgBox<\/span> \"Die Tabelle 'MSysResources' mit den Images für die Anzeige im Ribbon fehlt.\", vbOKOnly + vbExclamation, _\r\n \"Tabelle MSysResources fehlt\"\r\n Exit Sub<\/span>\r\n End If<\/span>\r\n On Error GoTo<\/span> 0\r\n If <\/span>lngID = 0 Then<\/span>\r\n MsgBox<\/span> \"Das Image '\" & control & \"' ist nicht in der Tabelle MSysResources vorhanden. \" & vbCrLf<\/span> _\r\n & \"Fügen Sie dieses hinzu, indem Sie im Formularentwurf die Funktion zum Einfügen von Bildern nutzen,\" _\r\n & \"ohne das Bild zum Formular selbst hinzuzufügen.\"\r\n Else<\/span>\r\n Set<\/span> image = PicFromSharedResource_Ribbon(CStr(control.Tag))\r\n End If<\/span>\r\nEnd Sub<\/span><\/pre>\n<button label=\"Beispielbutton1\" id=\"btn1\" onAction=\"onAction\" getImage=\"getImage\" tag=\"close\"\/><\/pre>\n
Unterschied zwischen loadImage und getImage<\/h2>\n
\nHier geht es zur Bestellung des Jahresabonnements des Magazins Access [basics]<\/strong>:<\/span>
\nZur Bestellung ...<\/a><\/span>
\nDanach greifen Sie sofort auf alle rund 400 Artikel<\/strong> unseres Angebots zu - auch auf diesen hier!<\/span>
\nOder haben Sie bereits Zugangsdaten? Dann loggen Sie sich gleich hier ein:<\/span><\/p>\n<\/div>\n\n\t\n\t