<\/p>\n
Bild 1: Option zur Anzeige von Formularen im Registerkartenformat<\/span><\/b><\/p>\n Im Beitrag „Ribbonklassen“ haben wir gezeigt, wie Sie das Ribbon allein mit VBA-Code definieren können. Nun wollen wir diese Technik in einer kleinen Beispielanwendung demonstrieren, in der wir eine Adressenliste in einem Formular anzeigen und alle Befehle zu dieser Adressenliste im Ribbon einbauen – also etwa, um einen neuen Datensatz anzulegen, einen bestehenden Datensatz zu löschen oder die Details zu einem Datensatz anzuzeigen.<\/b><\/p>\n Dabei nutzen wir in diesem Fall im Gegensatz zu den meisten anderen Anwendungen den standardmäßig eingestellten Wert Dokumente im Registerkartenformat <\/b>der Option Dokumentfensteroptionen <\/b>in den Access-Optionen. Die Option Dokumentregisterkarten anzeigen <\/b>wollen wir allerdings deaktivieren (s. Bild 1).<\/p>\n Bild 1: Option zur Anzeige von Formularen im Registerkartenformat<\/span><\/b><\/p>\n Anschließend erstellen wir ein Formular, das alle Datensätze der Tabelle tblKunden <\/b>in der Datenblattansicht anzeigen soll. Normalerweise würden wir eine solche Ansicht als Unterformular in ein Hauptformular integrieren, um noch weitere Steuer-elemente für die Verwaltung der Daten in der Datenblattansicht bereitzustellen – etwa zum Anlegen neuer Datensätze, zum Löschen eines bestehenden Datensatzes oder auch um einen Datensatz zum Bearbeiten zu öffnen. Wenn wir allerdings einmal alle Befehle für den Zugriff auf die Adressdaten in das Ribbon verschieben, brauchen wir ja kein übergeordnetes Formular mehr.<\/p>\n Also legen Sie ein neues Formular an und speichern es unter dem Namen frmKundenuebersicht<\/b>. Diesem Formular weisen Sie als Datenherkunft die Abfrage qryKunden <\/b>zu, die alle Felder der Tabelle tblKunden <\/b>enthält und diese alphabetisch nach dem Nachnamen der Lieferanschrift sortiert (s. Bild 2).<\/p>\n Bild 2: Datenherkunft für das Hauptformular<\/span><\/b><\/p>\n Während ich den Screenshot dieser Abfrage machen möchte, stelle ich übrigens fest, warum ich persönlich nie mit der Option Dokumente im Registerkartenformat <\/b>arbeite: Damit lassen sich einfach keine vernünftigen Screenshots einzelner Access-Objekte machen. Eine Abfrage etwa wird komplett über das Access-Fenster verteilt. Ich müsste nun das Access-Fenster zusammenschrumpfen, um alles in adäquater Größe knipsen zu können und müsste den Screenshot dann noch manuell beschneiden, weil der Abfrageentwurf in diesem Fall kein eigenes Fenster ist, das man mit gängigen Screenshot-Tools leicht erfassen könnte. Also werde ich während der Erstellung dieses Beitrags wohl oder übel zwischen den einzelnen Ansichten wechseln müssen …<\/p>\n Die soeben erstellte Abfrage qryKunden <\/b>legen wir als Datenherkunft für ein neues Formular namens frmKundenuebersicht <\/b>fest. Danach ziehen Sie alle Felder der Datenherkunft aus der Feldliste in den Detailbereich des Formularentwurfs (s. Bild 3). Damit die Daten in der Datenblattansicht angezeigt werden, legen Sie für die Eigenschaft Standardansicht <\/b>den Wert Datenblatt <\/b>fest.<\/p>\n Bild 3: Entwurf des Hauptformulars frmKundenuebersicht<\/span><\/b><\/p>\n Ein Wechsel in die Formularansicht zeigt das Formular mit den gewünschten Daten, das wir nun um einige Funktionen anreichern wollen – und zwar, indem wir diese in das Ribbon der Anwendung aufnehmen.<\/p>\n Um alle Features des Ribbons zu erläutern, wollen wir die Kundenübersicht allerdings nicht direkt beim öffnen der Anwendung einblenden, sondern zunächst nur einen Ribbon-Eintrag anzeigen, der das öffnen der Kundenübersicht erlaubt. Erst beim öffnen dieser übersicht sollen dann die für dieses Formular spezifischen Befehle im Ribbon angezeigt werden. Wie dies gelingt, erfahren Sie in den folgenden Abschnitten.<\/p>\n Hinweis: Wenn Sie diese Anwendung als reine Adressverwaltung nutzen wollen, die immer die Kundenübersicht anzeigen soll, können Sie das Formular frmKundenuebersicht<\/b> natürlich auch direkt als Startformular angeben. Dann wird das von uns für dieses Formular festgelegte Ribbon automatisch mit eingeblendet.<\/p>\n Wenn Sie unsere Ribbon-Klassen nutzen wollen, um das Ribbon zu programmieren, müssen Sie zuvor einige Access-Objekte aus der Beispieldatenbank in Ihre Zieldatenbank importieren. Dabei handelt es sich um die folgenden Objekte (bei allen Objekten außer dem Makro AutoExec <\/b>handelt es sich um Standard- oder Klassenmodule):<\/p>\n Diese Objekte fügen Sie beispielsweise zur Zieldatenbank hinzu, indem Sie beide Datenbanken öffnen und nebeneinander platzieren und dann die Objekte von einem Navigationsbereich zum anderen ziehen.<\/p>\n Bevor Sie das Ribbon programmieren können, benötigen Sie auch noch einen Verweis auf die Bibliothek Microsoft Office x.0 Object Library <\/b>(s. Bild 4). Diesen fügen Sie über den Verweise<\/b>-Dialog hinzu (VBA-Editor, Menüeintrag Extras|Verweise<\/b>).<\/p>\n Bild 4: Verweis auf die Office-Bibliothek<\/span><\/b><\/p>\n Den Inhalt des Moduls StartRibbon<\/b> ersetzen Sie nun durch die Codezeilen aus Listing 1. Wir wollen im Startribbon zwei Schaltflächen anzeigen: Eines zum öffnen der Kundenübersicht und eine zum Beenden der Anwendung. Für diese Schaltflächen müssen wir Variablen des Typs clsButton <\/b>deklarieren und mit dem Schlüsselwort With-Events <\/b>ausstatten, da wir für diese ja Ereignisprozeduren hinterlegen wollen, die beim Anklicken der Button<\/b>-Elemente ausgelöst werden.<\/p>\n <\/p>\n Listing 1: Code für das Startribbon<\/span><\/b><\/p>\n Die Prozedur CreateRibbon <\/b>übernimmt die Erstellung des Ribbons. Sie legt zunächst ein neues Objekt des Typs clsRibbon <\/b>an. Dazu fügt sie mit der Add<\/b>-Methode ein neues Element zur Auflistung Ribbons <\/b>hinzu. Für dieses stellen wir nun die Eigenschaft StartFromScratch <\/b>auf den Wert True <\/b>ein. Auf diese Weise werden alle eingebauten Ribbon-Elemente ausgeblendet. Dann fügen wir über die Add<\/b>-Methode der Tabs<\/b>-Auflistung von objRibbon <\/b>ein neues Tab<\/b>-Element hinzu und legen mit der Eigenschaft Label <\/b>die Beschriftung Kundenverwaltung <\/b>fest.<\/p>\n Nun legen wir auf ähnliche Weise ein Group<\/b>-Element an und versehen es mit der überschrift übersicht<\/b>. Dieses Group<\/b>-Element erhält nun zwei Button<\/b>-Elemente, für die wir weiter oben bereits die Variablen btnKundenuebersicht <\/b>und btnBeenden <\/b>festgelegt haben.<\/p>\n Diese fügen wir mit der Add<\/b>-Methode der Controls<\/b>-Auflistung des Group<\/b>-Elements hinzu.<\/p>\n Für das erste Button<\/b>-Element legen wir direkt in der Add<\/b>-Methode als Name btnKundenuebersicht <\/b>fest. Danach tragen wir für die Eigenschaft Label <\/b>den Wert Kundenübersicht<\/b>, für Size <\/b>den Wert msoRibbonControlSizeLarge <\/b>(für eine große Schaltfläche) und für Image <\/b>den Wert users3<\/b> ein.<\/p>\n Die Schritte für die zweite Button<\/b>-Schaltfläche erfolgen analog, nur dass wir hier natürlich andere Eigenschaften angeben.<\/p>\n Zwischen die beiden Schaltflächen fügen wir mit .Con-trols.Add msoRibbonControlSeparator <\/b>noch eine Trennlinie ein. Nach dem Zusammenstellen der Ribbon-Definition ruft die Prozedur noch die Methode CreateStartRibbon <\/b>des Ribbons<\/b>-Objekts auf und übergibt als Parameter Main <\/b>als Name der Ribbon-Definition.<\/p>\n Wir müssen noch die Bilder zur Datenbank hinzufügen, die im Ribbon als Icons angezeigt werden sollen. Dazu öffnen Sie am einfachsten ein Formular in der Entwurfsansicht und klicken dann im Ribbon auf den Eintrag Entwurf|Steuerelemente|Bild einfügen|Durchsuchen… <\/b>Dies öffnet einen Grafik einfügen<\/b>-Dialog, mit dem Sie die Bilder auswählen können. Diese sollten für große Schaltflächen 32×32 Pixel groß sein, für kleine Schaltflächen 16×16 Pixel. Wenn Sie auf diese Weise ein oder mehrere Bilder hinzugefügt haben, sollten diese in der Liste unter Bild einfügen <\/b>im Ribbon zur Auswahl erscheinen (s. Bild 5).<\/p>\n Bild 5: Bilder für das Ribbon<\/span><\/b><\/p>\n Die dort angegebenen Namen sollten mit den Namen übereinstimmen, die Sie auch für die Eigenschaft Image <\/b>des Button<\/b>-Elements festgelegt haben.<\/p>\n Nun stellen Sie noch den Namen des Anwendungsribbons ein, was wieder in den Access-Optionen geschieht. Damit der Name Main <\/b>dort erscheint, müssen Sie jedoch einmal die soeben erstellte Methode CreateRibbon <\/b>aufrufen.<\/p>\n Wenn Sie nun im Direktfenster einmalig die Methode CreateRibbon <\/b>der Klasse Startribbon <\/b>aufrufen, wird das Ribbon erstellt und ist danach in der Liste der Ribbons in den Access-Optionen verfügbar (s. Bild 6):<\/p>\n Bild 6: Einstellen des Anwendungsribbons<\/span><\/b><\/p>\n Im Direktfenster des VBA-Editors wird nun zur Kontrolle auch der Code der erstellten Ribbon-Definition ausgegeben.<\/p>\n Wählen Sie den Eintrag Main<\/b> in den Access-Optionen aus. Nun fehlt nur noch ein AutoExec<\/b>-Makro, welches mit der Makroaktion AusführenCode <\/b>und dem Parameter RibbonLaden() <\/b>automatisch die Funktion RibbonLaden <\/b>aufruft.<\/p>\n Starten Sie dann die Datenbankanwendung neu, wird das Ribbon direkt angezeigt (s. Bild 7).<\/p>\n Bild 7: Startribbon<\/span><\/b><\/p>\n Damit können wir die Ereignisse für die Ribbon-Buttons erstellen, die wie folgt aussehen:<\/p>\n Die erste Prozedur öffnet das Formular frmKundenuebersicht<\/b>, die zweite schließt die Anwendung. Die Ereignisprozeduren legen Sie an, indem Sie im VBA-Fenster für das Modul StartRibbon <\/b>im linken Kombinationsfeld den Namen des Button<\/b>-Elements auswählten, für das Sie die Ereignisprozedur definieren wollen. Die Prozeduren werden dann automatisch angelegt, sofern Sie die Objektvariablen, hier btnKundenuebersicht <\/b>und btnBeenden <\/b>mit dem Schlüsselwort WithEvents <\/b>deklariert haben.<\/p>\n Das Modul enthält noch zwei weitere Property Get<\/b>-Prozeduren, die aber nur etwa zum Aktivieren, Deaktivieren, Einblenden und Ausblenden oder zum Einstellen von Button<\/b>-Eigenschaften von außen benötigt werden. Dies ist hier nicht der Fall.<\/p>\n Wenn Sie nun auf die Schaltfläche Kundenübersicht <\/b>klicken, erscheint im Arbeitsbereich das Formular frmKundenuebersicht <\/b>mit den enthaltenen Datensätzen in der Datenblattansicht. Wir haben zusätzlich noch die Option Navigationsbereich anzeigen <\/b>aus den Access-Optionen deaktiviert, damit nur noch Elemente der Anwendung erscheinen.<\/p>\n Allerdings taucht nun natürlich noch kein benutzerdefiniertes Ribbon auf, sobald das Formular erscheint, sondern das in Zusammenhang mit der Anzeige von Objekten in der Datenblattansicht automatisch eingeblendete Ribbon-Tab Datenblatt <\/b>(s. Bild 8).<\/p>\n Bild 8: Mit dem Datenblatt erscheint das entsprechende eingebaute Ribbon.<\/span><\/b><\/p>\n Hier wollen wir nun natürlich auch noch ein eigenes Ribbon einblenden. Dazu legen wir zunächst eine Ereignisprozedur für das Formular an, die durch das Ereignis Beim Laden <\/b>ausgelöst wird.<\/p>\n Diese enthält nur eine einzige Anweisung, welche eine weitere Prozedur aufruft, die auch im Klassenmodul des Formulars implementiert wird – nämlich die Prozedur CreateRibbon<\/b>:<\/p>\n Die Prozedur CreateRibbon <\/b>finden Sie in Listing 2. Sie stellt wiederum ein Ribbon<\/b>– mit einem Tab<\/b>– und einem Group<\/b>-Element zusammen und fügt diesem zunächst ein Button<\/b>-Element hinzu, welches das geöffnete Formular wieder schließen soll. In diesem Fall sorgt die abschließende Anweisung dafür, dass das mit der Methode Get-Ribbon <\/b>erstellte Ribbon namens ribKundenuebersicht <\/b>direkt der Eigenschaft RibbonName <\/b>des Formulars selbst zugeordnet wird. Dies entspricht dem Auswählen eines der Ribbons für die Eigenschaft Name des Menübands <\/b>des Formulars.<\/p>\n Listing 2: Code für das Ribbon des Formulars frmKundenuebersicht<\/span><\/b><\/p>\n Für dieses Button<\/b>-Element deklarieren wir wieder eine Variable mit dem Schlüsselwort WithEvents<\/b>:<\/p>\n Auch für dieses legen wir wieder eine Ereignisprozedur wie die folgende an. In diesem Fall soll das Formular geschlossen werden:<\/p>\n Damit wir auf die Eigenschaften dieser Schaltfläche zugreifen können, legen wir wieder eine öffentliche Property Get<\/b>-Methode fest, mit der die Schaltfläche von außen zugreifbar ist:<\/p>\n Wenn Sie nun das Formular mit der Schaltfläche Kundenübersicht <\/b>des Hauptribbons öffnen, wird direkt das dort definierte Ribbon eingeblendet. Das Ribbon-Tab Datenblatt <\/b>bleibt rechts daneben verfügbar, was auch sinnvoll ist (s. Bild 9).<\/p>\n Bild 9: Das Formular-Ribbon in Aktion<\/span><\/b><\/p>\n Wie Sie sehen, konnten Sie dieses Ribbon direkt beim öffnen des Formulars als Formularribbon anzeigen – die Anwendung muss hier also nicht erst geschlossen und erneut geöffnet werden, wie es bei dem Ribbon der Fall ist, das als Anwendungsribbon gleich nach dem Start der Anwendung eingeblendet werden soll. Hier reicht es aber auch aus, wenn Sie das Anwendungsribbon einmal angelegt und die Anwendung geschlossen und wieder geöffnet haben – sobald der Eintrag in der Liste der verfügbaren Ribbons vorliegt, können Sie ein Ribbon unter diesem Namen beliebig zusammenstellen.<\/p>\n Nun wollen wir unserem Ribbon weitere Schaltflächen hinzufügen, und zwar für folgende Funktionen:<\/p>\n Dazu fügen wir dem Klassenmodul des Formulars zunächst die entsprechenden Objektvariablen für die zu erstellenden Schaltflächen zu:<\/p>\n Dann erweitern wir den mittleren Teil der Prozedur CreateRibbon <\/b>um die entsprechenden Anweisungen. Zuvor fügen Sie, sofern verfügbar, noch die für die neuen Schaltflächen benötigten Bilddateien zur Anwendung hinzu (wie dies gelingt, haben wir bereits weiter oben gezeigt). Danach tragen Sie unterhalb der folgenden Anweisungen den Code zum Erstellen weiterer Schaltflächen ein:<\/p>\n Der Code für die erste Schaltfläche sieht wie folgt aus:<\/p>\n Und ist der Code zum Anlegen der weiteren beiden Schaltflächen:<\/p>\n Für die drei Schaltflächen können Sie nun über die beiden Kombinationsfelder im Kopf des Codefensters des Moduls Form_frmKundenuebersicht <\/b>Ereignisprozeduren anlegen und mit Code füllen. Die Details dazu schauen wir uns im zweiten Teil der Beitragsreihe an. Das Formular schaut nun wie in Bild 10 aus.<\/p>\n![\"Option](\"..\/fileadmin\/_temp_\/2017_03\/pic_1091_001.png\")
<\/p>\nHauptformular der Anwendung erstellen<\/h2>\n
![\"Datenherkunft](\"..\/fileadmin\/_temp_\/2017_03\/pic_1091_003.png\")
<\/p>\nRegisterkartenformat und Screenshots<\/h2>\n
Hauptformular anlegen<\/h2>\n
![\"Entwurf](\"..\/fileadmin\/_temp_\/2017_03\/pic_1091_002.png\")
<\/p>\nVorbereitungen für das Anlegen des Ribbons<\/h2>\n
\n
![\"Verweis](\"..\/fileadmin\/_temp_\/2017_03\/pic_1091_004.png\")
<\/p>\nDim <\/span>WithEvents btnKundenuebersicht As <\/span>clsButton\r\nDim <\/span>WithEvents btnBeenden As <\/span>clsButton\r\nPublic Sub <\/span>CreateRibbon()\r\n Dim <\/span>objRibbon As <\/span>clsRibbon\r\n Dim <\/span>objTab As <\/span>clsTab\r\n Dim <\/span>objGroup As <\/span>clsGroup\r\n Set<\/span> objRibbon = Ribbons.Add(\"Main\")\r\n With<\/span> objRibbon\r\n .StartFromScratch = True<\/span>\r\n Set<\/span> objTab = .Tabs.Add(\"tabKundenverwaltung\")\r\n With<\/span> objTab\r\n .Label = \"Kundenverwaltung\"\r\n Set<\/span> objGroup = .Groups.Add(\"grpUebersicht\")\r\n With<\/span> objGroup\r\n .Label = \"übersicht\"\r\n Set<\/span> btnKundenuebersicht = .Controls.Add(msoRibbonControlButton, \"btnKundenuebersicht\")\r\n With<\/span> btnKundenuebersicht\r\n .Label = \"Kundenübersicht\"\r\n .Size = msoRibbonControlSizelarge\r\n .Image = \"users3\"\r\n End With<\/span>\r\n .Controls.Add msoRibbonControlSeparator\r\n Set<\/span> btnBeenden = .Controls.Add(msoRibbonControlButton, \"btnBeenden\")\r\n With<\/span> btnBeenden\r\n .Label = \"Beenden\"\r\n .Size = msoRibbonControlSizelarge\r\n .Image = \"close\"\r\n End With<\/span>\r\n End With<\/span>\r\n End With<\/span>\r\n End With<\/span>\r\n Ribbons.CreateStartRibbon \"Main\"\r\nEnd Sub<\/span>\r\nPublic Property Get <\/span>Beenden() As <\/span>clsButton\r\n Set<\/span> Beenden = btnBeenden\r\nEnd Property<\/span>\r\nPublic Property Get <\/span>Kundenuebersicht() As <\/span>clsButton\r\n Set<\/span> Kundenuebersicht = btnKundenuebersicht\r\nEnd Property<\/span>\r\nPrivate Sub <\/span>btnBeenden_OnAction(control As <\/span>Office.IRibbonControl)\r\n DoCmd.Quit\r\nEnd Sub<\/span>\r\nPrivate Sub <\/span>btnKundenuebersicht_OnAction(control As <\/span>Office.IRibbonControl)\r\n DoCmd.OpenForm \"frmKundenuebersicht\"\r\nEnd Sub<\/span><\/pre>\nBilder hinzufügen<\/h2>\n
![\"Bilder](\"..\/fileadmin\/_temp_\/2017_03\/pic_1091_005.png\")
<\/p>\nRibbon bereitstellen<\/h2>\n
![\"Einstellen](\"..\/fileadmin\/_temp_\/2017_03\/pic_1091_006.png\")
<\/p>\nStartribbon.CreateRibbon<\/pre>\n
![\"Startribbon\"](\"..\/fileadmin\/_temp_\/2017_03\/pic_1091_007.png\")
<\/p>\nEreignisse der Schaltflächen<\/h2>\n
Private Sub <\/span>btnKundenuebersicht_OnAction(control As <\/span> Office.IRibbonControl)\r\n DoCmd.OpenForm \"frmKundenuebersicht\"\r\nEnd Sub<\/span>\r\nPrivate Sub <\/span>btnBeenden_OnAction(control As <\/span> Office.IRibbonControl)\r\n DoCmd.Quit\r\nEnd Sub<\/span><\/pre>\nRibbon für die Kundenübersicht<\/h2>\n
![\"Mit](\"..\/fileadmin\/_temp_\/2017_03\/pic_1091_008.png\")
<\/p>\nPrivate Sub <\/span>Form_Load()\r\n CreateRibbon\r\nEnd Sub<\/span><\/pre>\nPrivate Sub <\/span>CreateRibbon()\r\n Dim <\/span>objRibbon As <\/span>clsRibbon\r\n Dim <\/span>objTab As <\/span>clsTab\r\n Dim <\/span>objGroup As <\/span>clsGroup\r\n Set<\/span> objRibbon = Ribbons.Add(\"ribKundenuebersicht\")\r\n With<\/span> objRibbon\r\n .StartFromScratch = True<\/span>\r\n Set<\/span> objTab = .Tabs.Add(\"tabKundenuebersicht\")\r\n With<\/span> objTab\r\n .Label = \"Kundenübersicht\"\r\n Set<\/span> objGroup = .Groups.Add(\"grpVerwalten\")\r\n With<\/span> objGroup\r\n .Label = \"Verwalten\"\r\n Set<\/span> btnSchliessen = .Controls.Add(msoRibbonControlButton, \"btnSchliessen\")\r\n With<\/span> btnSchliessen\r\n .Label = \"Schließen\"\r\n .Size = msoRibbonControlSizelarge\r\n .Image = \"close\"\r\n End With<\/span>\r\n End With<\/span>\r\n End With<\/span>\r\n End With<\/span>\r\n Me.RibbonName = Ribbons.GetRibbon(\"ribKundenuebersicht\")\r\nEnd Sub<\/span><\/pre>\nDim <\/span>WithEvents btnSchliessen As <\/span>clsButton<\/pre>\nPrivate Sub <\/span>btnSchliessen_OnAction( control As <\/span>Office.IRibbonControl)\r\n DoCmd.Close acForm, Me.Name\r\nEnd Sub<\/span><\/pre>\nPublic Property Get <\/span>Schliessen() As <\/span>clsButton\r\n Set<\/span> Schliessen = btnSchliessen\r\nEnd Property<\/span><\/pre>\n![\"Das](\"..\/fileadmin\/_temp_\/2017_03\/pic_1091_009.png\")
<\/p>\nWeitere Schaltflächen hinzufügen<\/h2>\n
\n
Dim <\/span>WithEvents btnNeuerKunde As <\/span>clsButton\r\nDim <\/span>WithEvents btnKundeBearbeiten As <\/span>clsButton\r\nDim <\/span>WithEvents btnKundeLoeschen As <\/span>clsButton<\/pre>\nWith<\/span> objGroup\r\n .Label = \"Verwalten\"\r\n ...<\/pre>\nSet<\/span> btnNeuerKunde = .Controls.Add( msoRibbonControlButton, \"btnNeuerKunde\")\r\nWith<\/span> btnNeuerKunde\r\n .Label = \"Neuer Kunde\"\r\n .Size = msoRibbonControlSizelarge\r\n .Image = \"user_add\"\r\nEnd With<\/span><\/pre>\nSet<\/span> btnKundeBearbeiten = .Controls.Add( msoRibbonControlButton, \"btnKundeBearbeiten\")\r\nWith<\/span> btnKundeBearbeiten\r\n .Label = \"Kunde bearbeiten\"\r\n .Size = msoRibbonControlSizelarge\r\n .Image = \"user_edit\"\r\nEnd With<\/span>\r\nSet<\/span> btnKundeLoeschen = .Controls.Add( msoRibbonControlButton, \"btnKundeLoeschen\")\r\nWith<\/span> btnKundeLoeschen\r\n .Label = \"Kunde löschen\"\r\n .Size = msoRibbonControlSizelarge\r\n .Image = \"user_delete\"\r\nEnd With<\/span><\/pre>\n![\"Formularribbon](\"..\/fileadmin\/_temp_\/2017_03\/pic_1091_010.png\")
<\/p>\n