<\/p>\n
Das Ribbon lässt sich normalerweise nur definieren, indem Sie den XML-Code zur Beschreibung des Ribbons festlegen, in einer bestimmten Tabelle speichern und die dortigen Einträge dann als Anwendungsribbon nutzen oder bestimmten Formularen oder Berichten zuweisen. Mit hier vorgestellten Klassen können Sie das Ribbon von nun an ganz einfach per VBA zusammenstellen und etwa Formularen oder Berichten zuweisen.<\/b><\/p>\n
Wie funktioniert das nun – ein Ribbon anzuzeigen, ohne die Tabelle USysRibbons<\/b> mit Ribbon-Definitionen zu füllen beziehungsweise gänzlich ohne statisch definierte Ribbons Grundsätzlich ist das ganz einfach: Sie benötigen lediglich einige Objekte aus der Beispieldatenbank zu diesem Beitrag, die Sie über die Importieren-Funktion in die Datenbank importieren, die Sie mit Ribbons ausstatten möchten.<\/p>\n
Dabei handelt es sich um die folgenden Objekte:<\/p>\n
Außerdem sind noch drei Schritte nötig:<\/p>\n
![\"Verweis](\"..\/fileadmin\/_temp_\/2017_01\/pic_1069_002.png\")
<\/p>\n
Bild 1: Verweis auf die Office-Bibliothek<\/span><\/b><\/p>\n Bild 2: Option, um das Anwendungsribbon einzustellen<\/span><\/b><\/p>\n Bild 3: Aktivieren der Anzeige von Ribbon-Fehlern<\/span><\/b><\/p>\n<\/ul>\n Zum Anzeigen von Ribbons gibt es auf herkömmlichem Wege zwei Möglichkeiten: Entweder Sie tragen den Namen der gewünschten Ribbon-Definition, die Sie in der Tabelle USysRibbons <\/b>gespeichert haben, für die oben genannte Eigenschaft in den Access-Optionen ein – dann wird das entsprechende Ribbon gleich beim Anwendungsstart angezeigt. Oder Sie möchten, dass das Ribbon mit einem Formular oder Bericht eingeblendet wird.<\/p>\n Dann tragen Sie den Namen des Ribbons für die entsprechende Eigenschaft des Formulars oder Berichts ein.<\/p>\n Wir verwenden in der hier vorgestellten Lösung zwar keine Tabelle namens USysRibbons <\/b>zum Speichern von Ribbon-Definitionen, aber wir können dennoch beide Methoden zum Anzeigen von Ribbons nutzen. Für die erste Methode ist die obige Angabe des Standardribbons nötig, beispielsweise über den Namen Main<\/b>.<\/p>\n Außerdem brauchen Sie ein AutoExec<\/b>-Makro, das dafür sorgt, dass das Ribbon auch direkt beim öffnen der Anwendung angezeigt wird.<\/p>\n Dieses Makro definieren Sie wie in Bild 4. Der einzige Makrobefehl lautet AusführenCode <\/b>und ruft die Funktion RibbonLaden <\/b>auf. Diese Funktion ist im Modul mdlRibbons <\/b>definiert und sieht wie folgt aus:<\/p>\n Bild 4: AutoExec-Makro, das ein Ribbon einblenden soll<\/span><\/b><\/p>\n Hier wird also die Methode CreateRibbon <\/b>eines Objekts namens Startribbon <\/b>aufgerufen. Wie Sie weiter oben sehen, haben wir die entsprechende Klasse Startribbon <\/b>bereits in der Beispieldatenbank vorbereitet. Aber wie können wir die Methode CreateRibbon <\/b>dieser Klasse nutzen, ohne dass wir diese instanzieren Das ist kein Problem: Wie müssen die Klasse nur einmal in eine Textdatei exportieren und dann einige Eigenschaften, die im VBA-Editor nicht sichtbar sind, anpassen. In Bild 5 haben wird dies für die Klasse Ribbons <\/b>durchgeführt, die ebenfalls ohne Instanzierung genutzt werden soll.<\/p>\n Bild 5: Anpassen der Klasse Ribbons, damit diese nicht instanziert werden muss<\/span><\/b><\/p>\n Nun wollen wir in der Klasse StartRibbon <\/b>eine Methode namens CreateRibbon <\/b>anlegen, mit der wir ein Ribbon namens Main <\/b>definieren, das dann beim öffnen der Anwendung gleich angezeigt werden soll.<\/p>\n In dieser deklarieren wir nun zunächst ein Objekt des Typs clsRibbon<\/b>, das unsere Ribbon-Deklaration aufnimmt.<\/p>\n Wir wollen als Erstes lediglich ein leeres Tab<\/b>-Element hinzufügen, um zu zeigen, dass die Klassen auch wirklich ihr Werk verrichten. Dazu deklarieren wir auch noch ein Element des Typs clsTab<\/b>:<\/p>\n Das clsRibbon<\/b>-Element füllen wir dann mit einem Objekt, das die Add<\/b>-Methode der Ribbons<\/b>-Klasse liefert:<\/p>\n Dieses Objekt besitzt wie das entsprechende Element in der Ribbon-Definition eine Eigenschaft namens StartFromScratch<\/b>, die wir auf den Wert True <\/b>einstellen:<\/p>\n Dann fügen wir dem clsRibbon<\/b>-Element mit der Add<\/b>-Methode der Tabs<\/b>-Auflistung ein neues Tab<\/b>-Element hinzu. Den Namen übergeben wir als Parameter:<\/p>\n Für dieses Objekt legen wir die Beschriftung mit der Eigenschaft label<\/b> fest:<\/p>\n Danach rufen wir die Methode CreateStartRibbon <\/b>der Klasse Ribbons <\/b>auf und übergeben dieser den Namen des zu erstellenden Ribbons, also Main<\/b>:<\/p>\n Die vollständige Fassung dieser Prozedur finden Sie in Listing 1.<\/p>\n Listing 1: Die Methode CreateRibbon füllen Sie mit eigenen Anweisungen.<\/span><\/b><\/p>\n Anschließend schauen wir uns an, ob diese Art der Ribbon-Definition auch wirklich funktioniert. Dazu schließen Sie die Access-Datei und öffnen diese erneut, damit das AutoExec<\/b>-Makro ausgeführt wird. Es reicht nicht aus, einfach das Makro auszuführen, da das Main-Ribbon möglicherweise zu diesem Zeitpunkt schon installiert wurde und erneutes Anlegen zu einem Fehler führt (dies können Sie durch erneutes Aufrufen des AutoExec<\/b>-Makros ausprobieren). Beim erneuten öffnen der Anwendung sollte nun die Ansicht aus Bild 6 erscheinen. Es funktioniert!<\/p>\n Bild 6: Das erste per VBA-Code erzeugte Ribbon<\/span><\/b><\/p>\n Nun gehen wir einen Schritt weiter und wollen dem Tab<\/b>-Element eine Gruppe hinzufügen – und natürlich auch noch Button<\/b>-Elemente. Die einfachste Variante sieht nun wie in Listing 2 aus. Sie sehen hier, dass wir ein weiteres Objekt des Typs clsGroup <\/b>mit dem Variablennamen obj-Group <\/b>deklariert haben. Dieses fügen wir dann über die Add<\/b>-Methode der Groups<\/b>-Auflistung des clsTab<\/b>-Objekts zum Ribbon hinzu. Auch dieses Objekt hält eine Eigenschaft namens label <\/b>bereit, mit der Sie die Beschriftung der Gruppe festlegen können. Diese legen wir hier mit dem Ausdruck Beispielgruppe <\/b>fest.<\/p>\n Listing 2: Anlegen eines Ribbons, diesmal mit einer Gruppe und zwei Schaltflächen<\/span><\/b><\/p>\n Danach folgen die beiden Button<\/b>-Elemente: Das erste fügen wir mit der Methode Add <\/b>der Auflistung Controls <\/b>des Objekts objGroup <\/b>hinzu. Dabei geben wir als ersten Parameter den Wert msoRibbonControlButton <\/b>an, was bewirkt, dass hier ein Button<\/b>-Element angelegt wird. Mit dem zweiten Parameter übergeben wir den Namen dieses Button<\/b>-Elements. Danach legen wir wiederum mit der Eigenschaft label <\/b>die Bezeichnung des Button<\/b>-Elements fest.<\/p>\n Wenn Sie aufgepasst haben, fällt Ihnen auf, dass die Prozedur gar keine Deklaration für die beiden Button-Elemente objButton1 <\/b>und objButton2 <\/b>enthält.<\/p>\n Das hat folgenden Grund: Unter anderem soll die Verwendung dieser Lösung dafür sorgen, dass Sie richtige Ereignisprozeduren für die Steuerelemente des Ribbons hinterlegen können. Das heißt, dass Sie die Ribbon-Elemente, die Ereignisse auslösen, mit dem Schlüsselwort WithEvents <\/b>deklarieren und dafür entsprechende Ereignisprozeduren anlegen können.<\/p>\n <\/p>\n Das gelingt, indem Sie zunächst die Deklaration im Kopf des Klassenmoduls vornehmen – für unsere beiden Schaltflächen also wie folgt:<\/p>\n Dann verwenden Sie die beiden Kombinationsfelder im Kopf des Modulfensters und wählen dort im linken Element den Namen des betroffenen Steuerelements, zum Beispiel objButton1<\/b>, und im rechten den Eintrag OnAction<\/b> aus. Dies legt dann automatisch die passende Ereignisprozedur an, die wir mit einer Test-Meldung füllen (s. Bild 7):<\/p>\n Bild 7: Deklarieren von Button-Elementen und Implementieren ihrer Ereignisse<\/span><\/b><\/p>\n In dieser Prozedur können wir dann gleich den Verweis auf das entsprechende Steuerelement nutzen, der mit dem Parameter control <\/b>geliefert wird.<\/p>\n Dies bietet zum Beispiel mit der Eigenschaft id <\/b>den Namen des angeklickten Steuerelements an, den wir hier gleich per Meldungsfenster ausgeben. Das Ergebnis des aktuellen Stands finden Sie in Bild 8.<\/p>\n Bild 8: Test der neuen Button-Elemente<\/span><\/b><\/p>\n Nun wollen wir natürlich auch die optischen Möglichkeiten des Ribbons nutzen und die Schaltflächen größer und mit Bildern anzeigen. Die dazu benötigten Bilder fügen Sie zur Systemtabelle MSysResources <\/b>hinzu.<\/p>\n Das gelingt am einfachsten, indem Sie ein Formular in der Entwurfsansicht öffnen und dann im Ribbon den Eintrag Entwurf|Steuerelemente|Bild einfügen <\/b>anklicken. Hier erscheint dann ein Eintrag namens Durchsuchen…<\/b>, mit dem Sie einen Grafik einfügen<\/b>-Dialog öffnen können (s. Bild 9).<\/p>\n Bild 9: Hinzufügen von Bildern zur Tabelle MSysResources<\/span><\/b><\/p>\n Damit fügen Sie dann die Bilddateien hinzu – für kleine Schaltflächen in der Größe 16×16, für große Schaltflächen in 32×32. Wenn Sie zuvor nicht das Formular anklicken, werden die Bilddateien noch nicht einmal direkt zum Formular hinzugefügt, sondern nur zur Tabelle MSysResources<\/b>.<\/p>\n Diese sieht dann etwa wie in Bild 10 aus. Die Definition passen wir nun wie folgt an:<\/p>\n Bild 10: Bilder in der Tabelle MSysResources<\/span><\/b><\/p>\n Wir haben hier erstens die Größe der Schaltflächen mit dem Wert msoRibbonControlSizeLarge <\/b>für die Eigenschaft Size <\/b>auf große Icons umgestellt.<\/p>\n Außerdem haben wir der Eigenschaft image <\/b>jeweils den Namen des anzuzeigenden Bildes hinzugefügt. Das Ergebnis sieht dann wie in Bild 11 aus.<\/p>\n Bild 11: Anzeige benutzerdefinierter Bilder<\/span><\/b><\/p>\n Sie können auch eines der zahlreichen eingebauten Icons nutzen. Diese lassen sich per IntelliSense abrufen, wenn Sie die Eigenschaft imageMso <\/b>verwenden (s. Bild 12).<\/p>\n Bild 12: Auswahl eingebauter Icons per IntelliSense<\/span><\/b><\/p>\n Beachten Sie: Sie können nur eine der beiden Eigenschaften zum Anzeigen von Bildern verwenden, also entweder image <\/b>oder imageMso<\/b>.<\/p>\n Wenn Sie schon einmal ein Ribbon programmiert haben und eine einzelne Schaltfläche etwa in Abhängigkeit von den angezeigten Daten ein- oder ausblenden wollten, wissen Sie, wie mühselig das Programmieren dieser Elemente ist.<\/p>\n Mit der hier vorgestellten Lösung ist dies wesentlich einfacher als mit der von Microsoft vorgesehenen Variante.<\/p>\n Um von außen etwa auf die Eigenschaft Visible <\/b>einer der Schaltflächen zuzugreifen, fügen Sie der Klasse Startribbon <\/b>einfach nur eine entsprechende Property Get<\/b>-Prozedur je betroffenem Steuerelement hinzu – also etwa so:<\/p>\n Wichtig ist, dass Sie den Variablentyp clsButton <\/b>für den Rückgabewert angeben.<\/p>\n Wenn Sie das Ribbon nun aktualisieren, indem Sie die Anwendung schließen und wieder öffnen (das geht übrigens am schnellsten durch Aufruf der Funktion Datenbank komprimieren und reparieren<\/b>), können Sie einmal das VBA-Fenster neben dem Access-Fenster platzieren und folgende Anweisung in das Direktfenster eingeben:<\/p>\n Damit deaktiveren Sie die erste Schaltfläche, die nun wie in Bild 13 ausgegraut erscheint. Sie können die Schaltfläche sogar ausblenden, indem Sie die Eigenschaft Visible <\/b>auf False <\/b>einstellen:<\/p>\n Bild 13: Steuerelemente aktivieren und deaktivieren<\/span><\/b><\/p>\n Mit den folgenden beiden Anweisungen blenden Sie die Schaltfläche wieder ein und aktivieren diese:<\/p>\n Das gelingt natürlich nicht nur vom Direktfenster aus, sondern auch etwa über die Ereignisprozeduren eines Formulars oder auch über die der Ribbon-Steuerelemente selbst. Statten wir doch die zweite Schaltfläche mit einer Prozedur aus, welche die erste Schaltfläche abwechselnd aktiviert und deaktiviert – je nachdem, welcher Zustand gerade vorherrscht:<\/p>\n Im Formular aus Bild 14 haben wir drei Schaltflächen untergebracht, die alle änderungen an der aktuellen Konstellation des Ribbons vornehmen. Der Code hinter den Schaltflächen sieht wie folgt aus. Neu ist hier insbesondere die Möglichkeit, das angezeigte Icon per Mausklick zu ändern:<\/p>\n Bild 14: Steuern des Ribbons vom Formular aus<\/span><\/b><\/p>\n In der Praxis bietet das Startribbon immer die für das Aufrufen der Funktionen der Anwendung benötigten Schaltflächen an. Gelegentlich gibt es noch weitere Steuerelemente wie etwa Kombinationsfelder oder auch Menüs, mit denen weitere Schaltflächen angeboten werden können.<\/p>\n Die aktuelle Version der hier vorgestellten Lösung bietet dies nicht an. Gegebenenfalls wird es jedoch eine erweiterte Fassung geben, die weitere Steuerelemente bereitstellt und auf amvshop.de <\/b>erworben werden kann.<\/p>\n Wenn Sie den Wunsch haben, direkt beim Start etwa je nach angemeldetem Benutzer bestimmte Steuerelemente zu aktivieren\/deaktivieren oder auch ein-\/auszublenden, legen Sie die benötigten Steuerelemente alle zunächst an und stellen dann beim Starten die Eigenschaften Visible <\/b>und Enabled <\/b>auf die gewünschten Werte ein. Ein nachträgliches, dynamisches Hinzufügen von Steuerelementen ist nicht möglich.<\/p>\n Diese Variante ist den Ribbons vorbehalten, die Sie zur Laufzeit in Zusammenhang mit der Anzeige von Formularen oder Berichten einblenden, wie die folgenden Abschnitte zeigen werden.<\/p>\n Sobald Sie über das Startribbon ein Formular geöffnet haben, gibt es zwei Möglichkeiten: Entweder Sie behalten das aktuelle Ribbon bei, etwa weil das Formular keine weiteren Steuerelemente im Ribbon benötigt oder Sie zeigen ein eigenes Ribbon an, welches formularspezifische Steuerelemente anbietet.<\/p>\n Wie dies gelingt, zeigt unser folgendes Beispiel. Dazu haben wir ein Formular namens frmEinfachesBeispiel <\/b>erstellt, das wir natürlich über unser Hauptribbon öffnen wollen. Bei der Gelegenheit haben wir dem Startribbon auch gleich einen Eintrag hinzugefügt, mit dem die aktuelle Anwendung komprimiert werden kann, was die schnellste Methode ist, die Datenbank zu schließen und wieder zu öffnen und somit die neue Ribbon-Definition bereitzustellen (siehe weiter unten).<\/p>\n Das Ribbon sieht nun wie in Bild 15 aus. Die Erweiterung für die Schaltfläche zum öffnen des Formulars in der Methode CreateRibbon <\/b>der Klasse StartRibbon <\/b>sieht so aus:<\/p>\n Bild 15: Zwei neue Ribbon-Befehle<\/span><\/b><\/p>\n Die Methode, die durch das Anklicken dieser Schaltfläche ausgelöst werden soll, sieht wie folgt aus:<\/p>\n![\"Option,](\"..\/fileadmin\/_temp_\/2017_01\/pic_1069_004.png\")
<\/p>\n![\"Aktivieren](\"..\/fileadmin\/_temp_\/2017_01\/pic_1069_015.png\")
<\/p>\nRibbons anzeigen<\/h2>\n
![\"AutoExec-Makro,](\"..\/fileadmin\/_temp_\/2017_01\/pic_1069_005.png\")
<\/p>\nPublic Function <\/span>RibbonLaden()\r\n Startribbon.CreateRibbon\r\nEnd Function<\/span><\/pre>\n![\"Anpassen](\"..\/fileadmin\/_temp_\/2017_01\/pic_1069_001.png\")
<\/p>\nPublic Sub <\/span>CreateRibbon()\r\n ...\r\nEnd Sub<\/span><\/pre>\nDim <\/span>objRibbon As <\/span>clsRibbon<\/pre>\nDim <\/span>objTab As <\/span>clsTab<\/pre>\n Set<\/span> objRibbon = Ribbons.Add(\"Main\")<\/pre>\n With<\/span> objRibbon\r\n .StartFromScratch = True<\/span><\/pre>\nSet<\/span> objTab = .Tabs.Add(\"Beispieltab\")<\/pre>\n With<\/span> objTab\r\n .label = \"Beispieltab\"\r\n End With<\/span>\r\n End With<\/span><\/pre>\n Ribbons.CreateStartRibbon \"Main\"\r\nEnd Sub<\/span><\/pre>\nPublic Sub <\/span>CreateRibbon()\r\n Dim <\/span>objRibbon As <\/span>clsRibbon\r\n Dim <\/span>objTab As <\/span>clsTab\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(\"Beispieltab\")\r\n With<\/span> objTab\r\n .label = \"Beispieltab\"\r\n End With<\/span>\r\n End With<\/span>\r\n Ribbons.CreateStartRibbon \"Main\"\r\nEnd Sub<\/span><\/pre>\n![\"Das](\"..\/fileadmin\/_temp_\/2017_01\/pic_1069_006.png\")
<\/p>\nGruppen und Schaltflächen hinzufügen<\/h2>\n
Public 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(\"Beispieltab\")\r\n With<\/span> objTab\r\n .label = \"Beispieltab\"\r\n Set<\/span> objGroup = .Groups.Add(\"Beispielgruppe\")\r\n With<\/span> objGroup\r\n .label = \"Beispielgruppe\"\r\n Set<\/span> objButton1 = .Controls.Add(msoRibbonControlButton, \"Beispielbutton\")\r\n objButton1.label = \"Button 1\"\r\n Set<\/span> objButton2 = .Controls.Add(msoRibbonControlButton, \"Beispielbutton1\")\r\n objButton2.label = \"Button 2\"\r\n End With<\/span>\r\n End With<\/span>\r\n End With<\/span>\r\n Ribbons.CreateStartRibbon \"Main\"\r\nEnd Sub<\/span><\/pre>\nDim <\/span>WithEvents objButton1 As <\/span>clsButton\r\nDim <\/span>WithEvents objButton2 As <\/span>clsButton<\/pre>\n![\"Deklarieren](\"..\/fileadmin\/_temp_\/2017_01\/pic_1069_007.png\")
<\/p>\nPrivate Sub <\/span>objButton1_OnAction(control As <\/span>RibbonControl)\r\n MsgBox<\/span> control.id\r\nEnd Sub<\/span>\r\nPrivate Sub <\/span>objButton2_OnAction(control As <\/span>IRibbonControl)\r\n MsgBox<\/span> control.id\r\nEnd Sub<\/span><\/pre>\n![\"Test](\"..\/fileadmin\/_temp_\/2017_01\/pic_1069_008.png\")
<\/p>\nGroße Schaltflächen mit Bildern<\/h2>\n
![\"Hinzufügen](\"..\/fileadmin\/_temp_\/2017_01\/pic_1069_009.png\")
<\/p>\n![\"Bilder](\"..\/fileadmin\/_temp_\/2017_01\/pic_1069_010.png\")
<\/p>\nSet<\/span> objButton1 = .Controls.Add( msoRibbonControlButton, \"Beispielbutton\")\r\nWith<\/span> objButton1\r\n .label = \"Button 1\"\r\n .Size = msoRibbonControlSizelarge\r\n .image = \"add\"\r\nEnd With<\/span>\r\nSet<\/span> objButton2 = .Controls.Add( msoRibbonControlButton, \"Beispielbutton1\")\r\nWith<\/span> objButton2\r\n .label = \"Button 2\"\r\n .Size = msoRibbonControlSizelarge\r\n .image = \"close\"\r\nEnd With<\/span><\/pre>\n![\"Anzeige](\"..\/fileadmin\/_temp_\/2017_01\/pic_1069_011.png\")
<\/p>\nEingebaute Icons<\/h2>\n
![\"Auswahl](\"..\/fileadmin\/_temp_\/2017_01\/pic_1069_012.png\")
<\/p>\nEigenschaften nutzen am Beispiel Ein-\/Ausblenden<\/h2>\n
Public Property Get <\/span>Button1() As <\/span>clsButton\r\n Set<\/span> Button1 = objButton1\r\nEnd Property<\/span>\r\nPublic Property Get <\/span>Button2() As <\/span>clsButton\r\n Set<\/span> Button2 = objButton2\r\nEnd Property<\/span><\/pre>\nStartribbon.Button1.Enabled = False<\/span><\/pre>\n![\"Steuerelemente](\"..\/fileadmin\/_temp_\/2017_01\/pic_1069_013.png\")
<\/p>\nStartribbon.Button1.visible = False<\/span><\/pre>\nStartribbon.Button1.Enabled = true\r\nStartribbon.Button1.visible = true<\/pre>\n
Private Sub <\/span>objButton2_OnAction(control As <\/span>IRibbonControl)\r\n objButton1.Enabled = Not<\/span> objButton1.Enabled\r\nEnd Sub<\/span><\/pre>\nBeispielaufrufe aus einem Formular heraus<\/h2>\n
![\"Steuern](\"..\/fileadmin\/_temp_\/2017_01\/pic_1069_014.png\")
<\/p>\nPrivate Sub <\/span>cmdBilder_Click()\r\n If <\/span>Startribbon.Button1.Image = \"add\" Then<\/span>\r\n Startribbon.Button1.Image = \"close\"\r\n Else<\/span>\r\n Startribbon.Button1.Image = \"add\"\r\n End If<\/span>\r\nEnd Sub<\/span>\r\nPrivate Sub <\/span>cmdEnabled_Click()\r\n Startribbon.Button1.Enabled = _\r\n Not<\/span> Startribbon.Button1.Enabled\r\nEnd Sub<\/span>\r\nPrivate Sub <\/span>cmdVisible_Click()\r\n Startribbon.Button1.Visible = _\r\n Not<\/span> Startribbon.Button1.Visible\r\nEnd Sub<\/span><\/pre>\nPraxistipps zum Startribbon<\/h2>\n
Ribbons für Formulare<\/h2>\n
![\"Zwei](\"..\/fileadmin\/_temp_\/2017_01\/pic_1069_016.png\")
<\/p>\n...\r\nSet<\/span> objGroup = .Groups.Add(\"grpFormulare\")\r\nWith<\/span> objGroup\r\n .Label = \"Formulare\"\r\n Set<\/span> objButtonForm = _\r\n .Controls.Add(msoRibbonControlButton, _\r\n \"btnfrmEinfachesBeispielOeffnen\")\r\n With<\/span> objButtonForm\r\n .Label = \"frmEinfachesBeispiel öffnen\"\r\n .Size = msoRibbonControlSizelarge\r\n .Image = \"form\"\r\n End With<\/span>\r\nEnd With<\/span>\r\n...<\/pre>\nPublic Property Get <\/span>ButtonForm() As <\/span>clsButton\r\n