Klickt man in Access auf den Registerreiter Datei<\/b>, öffnet sich der sogenannte Backstage-Bereich. Hier findet man Befehle wie Speichern<\/b>, Drucken<\/b> oder Optionen<\/b> sowie verschiedene Informationsbereiche. Was viele nicht wissen: Dieser Bereich lässt sich per XML-Definition umfangreich anpassen. Wir können eigene Befehle und Registerkarten hinzufügen, eingebaute Bereiche ausblenden und sogar vollständige Optionsseiten mit Textfeldern, Kontrollkästchen und Auswahllisten gestalten. In diesem Artikel zeigen wir Schritt für Schritt, wie das in Access funktioniert – direkt über die Systemtabelle USysRibbons<\/b> und VBA-Callback-Prozeduren.<\/b><\/p>\n
Beispieldatenbank<\/h2>\n
Die Beispiele zu diesem Artikel findest Du in der Beispieldatenbank. Diese enthält ein Modul mdlBackstageReferenz<\/b>, das die Tabelle USysRibbons<\/b> anlegt und mit der XML-Definition befüllt. Die Callback-Prozeduren befinden sich im Modul mdlBackstageCallbacks<\/b>. Führe im Direktbereich die Prozedur BackstageReferenz<\/b> aus, um die Tabelle zu erstellen.<\/p>\n
Danach trägst Du unter Datei|Optionen|Aktuelle Datenbank<\/b> den Ribbon-Namen BackstageRef<\/b> ein und startest Access neu (siehe Bild 1).<\/p>\n
![\"Auswählen](\"..\/fileadmin\/_temp_\/2026_02\/pic_468_001.png\")
<\/p>\n
Bild 1: Auswählen der aktuellen Ribbon-Definition<\/span><\/b><\/p>\n In der Beispieldatenbank findest Du ein Formular namens frmRibbonXML<\/b>, mit dem Du die Ribbon-Definitionen einfacher bearbeiten kannst, als direkt in der Tabelle (siehe Bild 2).<\/p>\n Bild 2: Formular zum Bearbeiten der Ribbon-Definitionen<\/span><\/b><\/p>\n Die Backstage-Definition verwendet den Namespace http:\/\/schemas.microsoft.com\/office\/2009\/07\/customui<\/b>. Dieser wurde mit Office 2010 eingeführt und ist die Voraussetzung dafür, dass das backstage<\/b>-Element überhaupt zur Verfügung steht. Der ältere Namespace 2006\/01<\/b> kennt kein backstage<\/b>-Element.<\/p>\n Jede Backstage-Definition beginnt daher mit dem folgenden Grundgerüst:<\/p>\n Das Attribut onLoad<\/b> im customUI<\/b>-Element verweist auf eine VBA-Callback-Prozedur, die beim Laden der Ribbon-Definition aufgerufen wird. Sie übergibt ein IRibbonUI<\/b>-Objekt, das wir in einer Modulvariablen speichern. Darüber können wir später die Anzeige aller Steuerelemente aktualisieren. Dazu legen wir im Modul mdlBackstage die folgenden Elemente an:<\/p>\n In Access speichern wir Ribbon- und Backstage-Definitionen in der Systemtabelle USysRibbons<\/b>. Diese Tabelle enthält mindestens die Spalten RibbonName<\/b> (Textfeld) und RibbonXml<\/b> (Memofeld) – siehe Bild 3.<\/p>\n Bild 3: Die Tabelle USysRibbons<\/span><\/b><\/p>\n Den Namen aus der Spalte RibbonName<\/b> tragen wir unter Datei|Optionen|Aktuelle Datenbank<\/b> im Feld Name des Menübands<\/b> ein. Beim nächsten Start der Datenbank liest Access die zugehörige XML-Definition ein und wendet sie an. Die Tabelle ist als Systemtabelle nur sichtbar, wenn Du im Navigationsbereich unter Navigationsoptionen<\/b> die Option Systemobjekte anzeigen<\/b> aktivierst.<\/p>\n Bevor wir eigene Elemente hinzufügen, werfen wir einen Blick auf die eingebauten Elemente des Backstage-Bereichs. Jedes Element besitzt einen eindeutigen idMso<\/b>-Wert, über den wir es referenzieren. In der Reihenfolge ihres Erscheinens sind das: PlaceTabHome<\/b> (Startseite), TabOfficeStart<\/b> (Office-Start), TabRecent<\/b> (Zuletzt verwendet), TabInfo<\/b> (Informationen), FileSave<\/b> (Speichern-Befehl), TabSave<\/b> (Speichern unter), TabPrint<\/b> (Drucken), FileCloseDatabase<\/b> (Schließen-Befehl), TabHelp<\/b> (Hilfe), TabOfficeFeedback<\/b> (Feedback) und ApplicationOptionsDialog<\/b> (Optionen-Befehl).<\/p>\n Es gibt also zwei Typen:<\/p>\n tab<\/b>-Elemente öffnen beim Anklicken einen Inhaltsbereich auf der rechten Seite, button<\/b>-Elemente führen direkt eine Aktion aus (siehe Bild 4).<\/p>\n Bild 4: Der Standard-Backstage-Bereich von Access mit allen eingebauten Elementen<\/span><\/b><\/p>\n Wir starten mit einem einfachen Befehl: einem button<\/b>-Element direkt unterhalb von backstage<\/b>.<\/p>\n Den folgenden Code fügen wir wie in Bild 5 in die Tabelle USysRibbons <\/b>ein und öffnen die Anwendung danach neu. Du findest die Ribbon-Definition in der Tabelle USysRibbons <\/b>unter EigenerBefehl<\/b>. Dann stellen wir in den Optionen die Eigenschaft Menüband <\/b>auf EigenerBefehl <\/b>ein, also auf den Wert der Spalte RibbonName<\/b>:<\/p>\n Bild 5: Ribbon-Definition für eine neue Schaltfläche im Backstage-Bereich<\/span><\/b><\/p>\n Dieses Element erscheint in der linken Befehlsleiste – genau wie die eingebauten Befehle Speichern<\/b> oder Schließen<\/b> (siehe Bild 6).<\/p>\n Bild 6: Neuer Befehl im Backstage-Bereich<\/span><\/b><\/p>\n Das Attribut insertAfterMso=”TabInfo”<\/b> sorgt dafür, dass der Befehl nach dem Informationen-Bereich eingefügt wird. Mit imageMso<\/b> weisen wir eines der eingebauten Office-Icons zu. Der Callback onAction<\/b> verweist auf die VBA-Prozedur, die beim Klick aufgerufen wird. Die Signatur dieser Prozedur sieht so aus:<\/p>\n Die Prozedur empfängt ein IRibbonControl<\/b>-Objekt. Über dessen Eigenschaft Id<\/b> lässt sich ermitteln, welches Steuerelement den Aufruf ausgelöst hat. So können wir mit einer einzigen Prozedur die Klicks mehrerer Backstage-Elemente verarbeiten.<\/p>\n Über das tab<\/b>-Element legen wir eine eigene Registerkarte an. Diese erzeugt einen Eintrag in der linken Befehlsleiste, der beim Anklicken einen Inhaltsbereich auf der rechten Seite öffnet. Das tab<\/b>-Element enthält bis zu zwei Spalten: firstColumn<\/b> und optional secondColumn<\/b>:<\/p>\n Innerhalb der Spalten platzieren wir group<\/b>-Elemente, die Steuerelemente thematisch zusammenfassen. Die Hierarchie lautet: tab<\/b> enthält firstColumn<\/b>\/secondColumn<\/b>, diese enthalten group<\/b>-Elemente, und darin befinden sich die Steuerelemente.<\/p>\n Ohne diese group<\/b>-Elemente sehen wir noch keine Elemente, wenn wir diese Ribbon-Definition anwenden. Also fügen wir diese nun hinzu. Den vollständigen Code findest Du in der Tabelle USysRibbons <\/b>unter EigeneRegisterkarte<\/b>. Wir erläutern diesen im Anschluss schrittweise.<\/p>\n Das group<\/b>-Element im Backstage-Bereich unterscheidet sich deutlich von dem im Ribbon. Es kann drei Unterbereiche enthalten: primaryItem<\/b>, topItems<\/b> und bottomItems<\/b>. Das primaryItem<\/b> zeigt ein großes Steuerelement (einen Button oder ein Menü) auf der linken Seite der Gruppe (siehe Bild 7).<\/p>\n Bild 7: Ein Element im Bereich primaryItem<\/span><\/b><\/p>\n topItems<\/b> und bottomItems<\/b> enthalten die regulären Steuerelemente oberhalb beziehungsweise unterhalb einer gedachten Trennlinie. Das Attribut helperText<\/b> zeigt einen erläuternden Text unterhalb des Gruppennamens:<\/p>\n Im Bereich topItems<\/b> haben wir einige Elemente wie ein labelControl<\/b>– und mehrere editBox<\/b>-Elemente untergebracht. Diese werden wie folgt definiert:<\/p>\n Das Ergebnis sehen wir in Bild 8. <\/p>\n Bild 8: Ein Element im Bereich topItem<\/span><\/b><\/p>\n Wie wir in der Abbildung sehen, “kleben” die Elemente alle am oberen Rand. Das liegt daran, dass wir die Überschrift noch ausgespart haben. Diese fügen wir nicht etwa als eigenes Element ein, aondern wir legen diese direkt für das tab<\/b>-Element fest:<\/p>\n Damit sieht der Bereich bereits viel harmonischer aus (siehe Bild 9).<\/p>\n Bild 9: Backstage-Bereich mit Überschrift<\/span><\/b><\/p>\n Hier verwenden wir einige Callback-Funktionen. Das sind Funktionen, die beim Anzeigen der Ribbon-Elemente ausgelöst werden und für die wir entsprechende Funktionen im VBA-Projekt hinterlegen. Diese findest Du im Modul mdlBackstage<\/b>.<\/p>\n Das einfachste Steuerelement ist labelControl<\/b>: Es zeigt einen statischen Text an, ohne dass der Benutzer damit interagieren kann. Das ist nützlich für Hinweise oder Überschriften innerhalb einer Gruppe:<\/p>\n Die XSD-Definition zeigt, dass labelControl<\/b> neben id<\/b> und label<\/b> auch die Attribute alignLabel<\/b>, expand<\/b>, enabled<\/b>, visible<\/b> und noWrap<\/b> unterstützt.<\/p>\n Mit noWrap=”true”<\/b> verhindern wir, dass ein langer Text umgebrochen wird.<\/p>\n Mit editBox<\/b> erstellen wir ein Textfeld, in das der Benutzer Freitext eingeben kann. Das Steuerelement arbeitet mit zwei Callbacks: getText<\/b> liefert den aktuell anzuzeigenden Wert, onChange<\/b> wird ausgelöst, wenn der Benutzer den Wert ändert und das Feld verlässt.<\/p>\n Das Attribut sizeString<\/b> bestimmt die Breite des Eingabefelds – Access misst die Breite anhand des angegebenen Textes:<\/p>\n Die Callback-Funktion getText<\/b> wird aufgerufen, wenn Access den Inhalt des Feldes ermitteln möchte – also beim Öffnen des Backstage-Bereichs und nach einem Aufruf der Invalidate<\/b>-Methode. Sie gibt einen String<\/b> zurück:<\/p>\n Hier verwenden wir control.Id<\/b> direkt als Schlüssel für die Windows-Registry. So brauchen wir keinen langen Select Case<\/b>-Block, sondern können mit einer einzigen Funktion beliebig viele Textfelder bedienen.<\/p>\n Die Prozedur onChange<\/b> empfängt neben dem control<\/b>-Objekt den neuen Text als zweiten Parameter:<\/p>\n Die beiden Funktionen GetSetting <\/b>und SaveSetting <\/b>lesen beziehungsweise schreiben Einstellungen der Registry.<\/p>\n Wenn Du Daten in eines der editBox<\/b>-Elemente einträgst, werden diese in enem für VBA-Anwendungen reservierten Bereich der Registry eingetragen, von wo sie beim Anzeigen der jeweiligen Steuerelemente auch wieder ausgelesen werden. Der entsprechende Bereich der Registry sieht wie in Bild 10 aus.<\/p>\n Bild 10: Die im Backstage-Bereich eingegebenen Werte in der Registry<\/span><\/b><\/p>\n Im bottomItems<\/b>-Bereich der Gruppe platzieren wir ein hyperlink<\/b>-Element. Dieses zeigt einen anklickbaren Link an, der eine URL im Standardbrowser öffnet. <\/p>\n as Attribut target<\/b> enthält die Ziel-URL:<\/p>\n Das hyperlink<\/b>-Element unterstützt laut XSD auch die Attribute onAction<\/b> (zum Ausführen von VBA-Code statt einer URL), imageMso<\/b> (für ein Icon) sowie screentip<\/b> und supertip<\/b> (für Tooltips).<\/p>\n Man kann statt target<\/b> auch getTarget<\/b> verwenden, um die URL dynamisch per Callback zu bestimmen.<\/p>\n In der zweiten Spalte unserer Registerkarte (secondColumn<\/b>) platzieren wir eine Gruppe mit Auswahl-Steuerelementen, und zwar das checkBox<\/b>-Element, das dropDown<\/b>-Element, das comboBox<\/b>-Element und das radioGroup<\/b>-Element (siehe Bild 11).<\/p>\n Bild 11: Elemente im Bereich secondColumn<\/span><\/b><\/p>\n Das checkBox<\/b>-Element erzeugt ein Kontrollkästchen. Es verwendet den Callback getPressed<\/b>, um den aktuellen Zustand abzufragen, und onAction<\/b> für die Benachrichtigung bei einer Änderung. Im Backstage-Bereich unterstützt es zusätzlich das Attribut description<\/b>, das einen erläuternden Text unterhalb des Labels anzeigt:<\/p>\n Die Callback-Funktion getPressed<\/b> gibt einen Boolean<\/b>-Wert zurück:<\/p>\n Die Prozedur onActionToggle<\/b> empfängt den neuen Zustand als Boolean<\/b>-Parameter:<\/p>\n Ein dropDown<\/b> bietet dem Benutzer eine geschlossene Auswahlliste, aus der er genau einen Eintrag wählen kann. Die Einträge definieren wir statisch über item<\/b>-Unterelemente. Jedes item<\/b>-Element benötigt ein id<\/b>– und ein label<\/b>-Attribut:<\/p>\n Wichtig: Im Backstage-Bereich verwendet das dropDown<\/b>-Element den Callback getSelectedItemIndex<\/b> (nicht getSelectedItemID<\/b> wie im Ribbon). Die Funktion gibt den nullbasierten Index des vorausgewählten Eintrags zurück:<\/p>\n Die Callback-Prozedur onActionDropDown<\/b> empfängt neben dem control<\/b>-Objekt die id<\/b> des gewählten Eintrags als String<\/b> und den Index als Long<\/b>:<\/p>\n Die comboBox<\/b> kombiniert ein Textfeld mit einer Auswahlliste. Im Gegensatz zum dropDown<\/b> kann der Benutzer auch Freitext eingeben, der nicht in der Liste enthalten ist. Die comboBox<\/b> verwendet die gleichen Callbacks wie die editBox<\/b> – also getText<\/b> und onChange<\/b> – und bietet zusätzlich statische item<\/b>-Einträge als Vorschläge:<\/p>\n Da comboBox<\/b> dieselben Callbacks getText<\/b> und onChange<\/b> verwendet wie editBox<\/b>, funktionieren unsere vorhandenen Callback-Funktionen auch hier ohne Änderungen.<\/p>\n Eine radioGroup<\/b> zeigt mehrere Optionsschaltflächen, von denen der Benutzer genau eine auswählen kann. Die Kindelemente heißen radioButton<\/b>. Genau wie beim dropDown<\/b> verwenden wir im Backstage-Bereich den Callback getSelectedItemIndex<\/b> für die Vorauswahl und onAction<\/b> für Änderungen:<\/p>\n Die Prozedur onActionRadio<\/b> hat die gleiche Signatur wie onActionDropDown<\/b> – sie empfängt die id<\/b> des gewählten Eintrags und den Index und verarbeitet diese:<\/p>\n Wenn wir aus dem VBA-Code heraus eine Einstellung ändern, die im Backstage-Bereich angezeigt wird, müssen wir die Anzeige manuell aktualisieren. Dafür dient die Invalidate<\/b>-Methode des IRibbonUI<\/b>-Objekts, das wir beim onLoad<\/b>-Callback gespeichert haben:<\/p>\n Durch den Aufruf m_objRibbon.Invalidate<\/b> veranlassen wir Access, alle Callback-Funktionen wie getText<\/b>, getPressed<\/b> und getSelectedItemIndex<\/b> erneut aufzurufen, sodass die Steuerelemente die aktuellen Werte anzeigen. Möchten wir nur ein einzelnes Steuerelement aktualisieren, verwenden wir m_objRibbon.InvalidateControl “txtServer”<\/b>.<\/p>\n Der Backstage-Bereich von Access lässt sich über die Tabelle USysRibbons<\/b> und XML-Definitionen im Namespace 2009\/07<\/b> umfangreich anpassen. Wir können über das button<\/b>-Element einfache Befehle in der Leiste platzieren, mit dem tab<\/b>-Element vollständige Optionsseiten gestalten und eingebaute Bereiche per idMso<\/b> und visible=”false”<\/b> ausblenden.<\/p>\n Für Benutzereingaben stehen editBox<\/b>, checkBox<\/b>, dropDown<\/b>, comboBox<\/b> und radioGroup<\/b> zur Verfügung. Ergänzt werden sie durch labelControl<\/b> für statische Texte und hyperlink<\/b> für anklickbare Links.<\/p>\n Im nächsten Artikel mit dem Titel Backstage-Bereich von Office erweitern, Teil 2 <\/b>(www.vbentwickler.de\/500<\/b>) erweitern wir den Backstage-Bereich um die Layout-Elemente groupBox<\/b>, layoutContainer<\/b> und imageControl<\/b>. Außerdem zeigen wir, wie man mit taskFormGroup<\/b> und taskGroup<\/b> komplexere Aufgabenbereiche aufbaut.<\/p>\n Enthaltene Beispieldateien:<\/p>\n BackstageBereichProgrammieren.accdb<\/p>\nHilfsformular zum Bearbeiten der Ribbon-Definitionen<\/h2>\n
![\"Formular](\"..\/fileadmin\/_temp_\/2026_02\/pic_468_006.png\")
<\/p>\nVoraussetzungen<\/h2>\n
<customUI xmlns=\r\n \"http:\/\/schemas.microsoft.com\/office\/2009\/07\/customui\"\r\n onLoad=\"onLoad\">\r\n <backstage>\r\n ...\r\n <\/backstage>\r\n<\/customUI><\/pre>\n
Dim <\/span>m_objRibbon As <\/span>IRibbonUI\r\nPublic Sub <\/span>onLoad(ribbon As <\/span>IRibbonUI)\r\n Set<\/span> m_objRibbon = ribbon\r\nEnd Sub<\/span><\/pre>\nDie Tabelle USysRibbons<\/h2>\n
![\"Die](\"..\/fileadmin\/_temp_\/2026_02\/pic_468_002.png\")
<\/p>\nDie eingebauten Backstage-Elemente<\/h2>\n
![\"Der](\"..\/fileadmin\/_temp_\/2026_02\/pic_468_003.png\")
<\/p>\nEin eigener Befehl im Backstage-Bereich<\/h2>\n
![\"Ribbon-Definition](\"..\/fileadmin\/_temp_\/2026_02\/pic_468_004.png\")
<\/p>\n<customUI xmlns=\"http:\/\/schemas.microsoft.com\/office\/2009\/07\/ customui\" onLoad=\"onLoad\">\r\n <backstage>\r\n <button id=\"btnSchnell\" \r\n label=\"Schnellbefehl (button)\" insertAfterMso=\"TabInfo\" imageMso=\"FileSave\" onAction=\"onAction\"\/>\r\n <\/backstage>\r\n<\/customUI><\/pre>\n
![\"Neuer](\"..\/fileadmin\/_temp_\/2026_02\/pic_468_005.png\")
<\/p>\nPublic Sub <\/span>onAction(control As <\/span>IRibbonControl)\r\n MsgBox<\/span> \"onAction: \" & control.Id\r\nEnd Sub<\/span><\/pre>\nEine eigene Registerkarte anlegen<\/h2>\n
<tab id=\"tabSteuer\"\r\n label=\"Steuerelemente (tab)\"\r\n insertAfterMso=\"TabInfo\">\r\n <firstColumn>\r\n ...\r\n <\/firstColumn>\r\n <secondColumn>\r\n ...\r\n <\/secondColumn>\r\n<\/tab><\/pre>\n
Gruppen mit primaryItem, topItems und bottomItems<\/h2>\n
![\"Ein](\"..\/fileadmin\/_temp_\/2026_02\/pic_468_007.png\")
<\/p>\n<group id=\"grpTexte\"\r\n label=\"Texteingaben (group)\"\r\n helperText=\"Dieser Text kommt aus dem Attribut helperText.\">\r\n <primaryItem>\r\n <button id=\"btnSpeichern\"\r\n label=\"Speichern\r\n (primaryItem > button)\"\r\n imageMso=\"FileSave\"\r\n onAction=\"onAction\"\/>\r\n <\/primaryItem>\r\n <topItems>\r\n ...\r\n <\/topItems>\r\n <bottomItems>\r\n ...\r\n <\/bottomItems>\r\n<\/group><\/pre>\n
Elemente im Bereich topItems<\/h2>\n
<topItems>\r\n <labelControl id=\"lblHinweis\" label=\"Dies ist ein labelControl\"\/>\r\n <editBox id=\"txtServer\" label=\"Server (editBox)\" getText=\"getText\" onChange=\"onChange\" sizeString=\"yyyyyyyyyyyyyyyyyy\"\/>\r\n <editBox id=\"txtDatenbank\" label=\"Datenbank (editBox)\" getText=\"getText\" onChange=\"onChange\" sizeString=\"yyyyyyyyyyyyyyyyyy\"\/>\r\n <editBox id=\"txtBenutzer\" label=\"Benutzer (editBox)\" getText=\"getText\" onChange=\"onChange\" sizeString=\"yyyyyyyyyyyyyyyyyy\"\/>\r\n<\/topItems><\/pre>\n
![\"Ein](\"..\/fileadmin\/_temp_\/2026_02\/pic_468_008.png\")
<\/p>\nWichtig: Die Überschrift<\/h2>\n
<tab id=\"tabSteuer\" label=\"Steuerelemente (tab)\" \r\n insertBeforeMso=\"FileSave\" \r\n title=\"Beispiele für Steuerelemente\"><\/pre>\n
![\"Backstage-Bereich](\"..\/fileadmin\/_temp_\/2026_02\/pic_468_011.png\")
<\/p>\nCallback-Funktionen<\/h2>\n
Das labelControl-Element<\/h2>\n
<labelControl id=\"lblHinweis\"\r\n label=\"Dies ist ein labelControl\"\/><\/pre>\n
Das editBox-Element<\/h2>\n
<editBox id=\"txtServer\" label=\"Server (editBox)\"\r\n getText=\"getText\" onChange=\"onChange\"\r\n sizeString=\"yyyyyyyyyyyyyyyyyy\"\/><\/pre>\n
Public Function <\/span>getText(control As <\/span>IRibbonControl, _\r\n ByRef text)\r\n text = GetSetting(\"Backstage-Beispiel\", \"Optionen\", _\r\n control.ID, \"\")\r\nEnd Function<\/span><\/pre>\nPublic Sub <\/span>onChange(control As <\/span>IRibbonControl, _\r\n text As String<\/span>)\r\n SaveSetting \"Backstage-Beispiel\", \"Optionen\", _\r\n control.ID, text\r\nEnd Sub<\/span><\/pre>\n![\"Die](\"..\/fileadmin\/_temp_\/2026_02\/pic_468_009.png\")
<\/p>\nDas hyperlink-Element<\/h2>\n
<hyperlink id=\"lnkHilfe\" label=\"Online-Hilfe (hyperlink)\"\r\n target=\"https:\/\/www.example.com\"\/><\/pre>\n
Elemente im Bereich secondColumn<\/h2>\n
![\"Elemente](\"..\/fileadmin\/_temp_\/2026_02\/pic_468_010.png\")
<\/p>\nDas checkBox-Element<\/h2>\n
<checkBox id=\"chkProtokoll\" label=\"Protokollierung (checkBox)\"\r\n description=\"Text aus dem Attribut description\"\r\n getPressed=\"getPressed\"\r\n onAction=\"onActionToggle\"\/><\/pre>\n
Public Function <\/span>getPressed(control As <\/span>IRibbonControl, _\r\n ByRef returnValue)\r\n returnValue = GetSetting(\"Backstage-Beispiel\", _\r\n \"Optionen\", control.ID, \"0\")\r\nEnd Function<\/span><\/pre>\nPublic Sub <\/span>onActionToggle(control As <\/span>IRibbonControl, _\r\n bolPressed As Boolean<\/span>)\r\n SaveSetting \"Backstage-Beispiel\", \"Optionen\", _\r\n control.ID, bolPressed 'strWert\r\nEnd Sub<\/span><\/pre>\nDas dropDown-Element<\/h2>\n
<dropDown id=\"ddSprache\" label=\"Sprache (dropDown)\"\r\n getSelectedItemIndex=\"getSelectedItemIndex\"\r\n onAction=\"onActionDropDown\">\r\n <item id=\"itemDE\" label=\"Deutsch (item)\"\/>\r\n <item id=\"itemEN\" label=\"Englisch (item)\"\/>\r\n <item id=\"itemFR\" label=\"Franzoesisch\r\n (item)\"\/>\r\n<\/dropDown><\/pre>\n
Public Function <\/span>getSelectedItemIndex( _\r\n control As <\/span>IRibbonControl, ByRef index)\r\n index = CLng(GetSetting(\"Backstage-Beispiel\", _\r\n \"Optionen\", control.ID, \"0\"))\r\nEnd Function<\/span><\/pre>\nPublic Sub <\/span>onActionDropDown(control As <\/span>IRibbonControl, _\r\n selectedID As String<\/span>, selectedIndex As Integer<\/span>)\r\n SaveSetting \"Backstage-Beispiel\", \"Optionen\", _\r\n control.ID, CStr(selectedIndex)\r\nEnd Sub<\/span><\/pre>\nDas comboBox-Element<\/h2>\n
<comboBox id=\"cboFormat\" label=\"Exportformat (comboBox)\"\r\n getText=\"getText\" \r\n onChange=\"onChange\"\r\n sizeString=\"yyyyyyyyyyyyyy\">\r\n <item id=\"itemCSV\" \r\n label=\"CSV (item)\"\/>\r\n <item id=\"itemXLSX\" \r\n label=\"Excel (item)\"\/>\r\n <item id=\"itemJSON\" label=\"JSON (item)\"\/>\r\n<\/comboBox><\/pre>\n
Das radioGroup-Element<\/h2>\n
<radioGroup id=\"rgModus\" label=\"Betriebsmodus (radioGroup)\"\r\n getSelectedItemIndex=\"getSelectedItemIndex\"\r\n onAction=\"onActionRadio\">\r\n <radioButton id=\"rbNormal\" label=\"Normal\r\n (radioButton)\"\/>\r\n <radioButton id=\"rbDebug\" label=\"Debug\r\n (radioButton)\"\/>\r\n <radioButton id=\"rbSilent\" label=\"Lautlos\r\n (radioButton)\"\/>\r\n<\/radioGroup><\/pre>\n
Public Sub <\/span>onActionDropDown(control As <\/span>IRibbonControl, _\r\n selectedID As String<\/span>, selectedIndex As Integer<\/span>)\r\n SaveSetting \"Backstage-Beispiel\", \"Optionen\", _\r\n control.ID, CStr(selectedIndex)\r\nEnd Sub<\/span><\/pre>\nSteuerelemente zur Laufzeit aktualisieren<\/h2>\n
Dim <\/span>m_objRibbon As <\/span>IRibbonUI\r\nPublic Sub <\/span>onLoad(ribbon As <\/span>IRibbonUI)\r\n Set<\/span> m_objRibbon = ribbon\r\nEnd Sub<\/span><\/pre>\nZusammenfassung und Ausblick<\/h2>\n
Downloads zu diesem Beitrag<\/h2>\n