<\/p>\n
Neben COM-Add-Ins für Access selbst (und natürlich auch für die übrigen Office-Anwendungen) können Sie mit twinBASIC auch COM-Add-Ins für den VBA-Editor programmieren. Dieser Beitrag beleuchtet detailliert, welche Schritte dazu notwendig sind. Dabei beginnen wir mit einer COM-Add-In-Vorlage, die wir für unseren Anwendungszweck anpassen. Anders als bei COM-Add-Ins für Access können Sie die Funktionen von COM-Add-Ins für den VBA-Editor nicht per Ribbon-Eintrag aufrufen, sondern benötigen einen Menüleisteneintrag dafür. Wir erläutern, wie dieser erzeugt wurd und wie Sie dann auf die Elemente des VBA-Editors zugreifen können.<\/b><\/p>\ntwinBASIC<\/h2>\n
Im Beitrag twinBASIC – VB\/VBA mit moderner Umgebung <\/b>(www.access-im-unternehmen.de\/1303<\/b>) zeigen wir, was twinBASIC ist und wie Sie es installieren. twinBASIC ist eine Programmierumgebung auf Basis von Visual Studio Code mit einer Erweiterung von Wayne Philips, den manche vielleicht schon als Entwickler des Fehlerbehandlungstools vbWatchDog <\/b>kennen. Sie können damit aktuell EXE-Dateien ohne Benutzeroberfläche erstellen oder DLLs, die Sie in Access-VBA-Projekte einbinden – siehe COM-DLLs mit twinBASIC <\/b>(www.access-im-unternehmen.de\/1304<\/b>). Außerdem können Sie damit COM-Add-Ins erstellen. Im Beitrag twinBASIC – COM-Add-Ins für Access <\/b>(www.access-im-unternehmen.de\/1306<\/b>) erfahren Sie, wie Sie COM-Add-Ins für Access-Anwendungen programmieren.<\/p>\nWozu COM-Add-Ins für den VBA-Editor<\/h2>\n
Wer immer nur mit Access programmiert und keine anderen Entwicklungsumgebungen als den VBA-Editor nutzt, hat sich vielleicht schon so sehr an die recht betagte Entwicklungsumgebung gewöhnt, dass er nichts vermisst. Wer jedoch gelegentlich über den Tellerrand schaut und sieht, welche Möglichkeiten andere Entwicklungsumgebungen bieten, würde sich vielleicht doch über die eine oder andere Weiterentwicklung freuen. Nun ist die Benutzeroberfläche von Access an sich seit der Version 2010 nicht mehr weiterentwickelt worden – bis auf einige unbedeutende Änderungen. Der Funktionsumfang wurde hingegen eher eingeschränkt – man denke an die Replikation und das Sicherheitssystem. Ein ähnliches Bild liefert der VBA-Editor. Genau genommen liegen hier die letzten Änderungen noch länger zurück.<\/p>\n
Gelegentlich hat ein Entwickler Ideen, wie er den VBA-Editor verbessern könnte, was theoretisch auch mit .NET-COM-Add-Ins möglich wäre. Es gibt einige Vorlagen, mit denen man Word-, Excel- oder Outlook-Erweiterungen programmieren kann. Für Access oder auch für den VBA-Editor gibt es jedoch keine Projektvorlagen, also müsste man schon komplett selbst herausfinden, an welchen Stellen in den Vorlagen für die anderen Office-Anwendungen man schrauben müsste.<\/p>\n
Da ist es doch erfrischend, dass Wayne Philips eine Möglichkeit bietet, COM-Add-Ins in einer neuen, alternativen Entwicklungsumgebung zum VBA-Editor und zu Visual Studio (.NET) zu entwickeln – von Visual Studio 6 reden wir erst gar nicht mehr, da damit nur die Entwicklung von Programmen auf Basis von 32-Bit möglich ist.<\/p>\n
Mit twinBASIC können Sie jedoch, wie auf den folgenden Seiten beschrieben, auch COM-Add-Ins für den VBA-Editor entwickeln und es ist sogar geplant, dass dies auch für die 64-Bit-Version von Office möglich sein soll (aktuell ist twinBASIC noch in einem frühen Entwicklungsstadium, Features wie die Programmierung von Userinterfaces beispielsweise folgen erst später).<\/p>\n
Auf der Webseite von Wayne Philips finden Sie unter dem Link https:\/\/twinbasic.com\/preview.html <\/b>einige Beispiele, darunter auch das Beispiel eines COM-Add-Ins. Dieses verwenden wir als Basis für unser erstes eigenes COM-Add-In für den VBA-Editor.<\/p>\n
Der Ordner in der Zip-Datei enthält vier Dateien:<\/p>\n
Die beiden ersten Dateien müssen immer den gleichen Namen aufweisen. Sie öffnen ein Projekt, indem Sie die Datei mit der Dateiendung code-workspace <\/b>öffnen (gegebenenfalls müssen Sie die Dateiendung noch mit Visual Studio Code verknüpfen).<\/p>\n
Dies liefert im nun erscheinenden Visual Studio Code die Ansicht aus Bild 1. Um weitere Dateien müssen Sie sich noch keine Gedanken machen, aktuell reicht eine Projektdatei mit dem Code völlig aus.<\/p>\n
![\"Entwicklungsumgebung](\"..\/fileadmin\/_temp_\/2021_03\/pic_1307_001.png\")
<\/p>\n
Bild 1: Entwicklungsumgebung mit dem Code des COM-Add-Ins für den VBA-Editor<\/span><\/b><\/p>\n Außerdem finden Sie noch Einstellungen, die wir uns nun ansehen und gegebenenfalls erweitern. Klicken Sie auf den Bereich Settings<\/b>, finden Sie einige interessante Eigenschaften vor, die wir an dieser Stelle kurz vorstellen wollen (siehe Bild 2):<\/p>\n Bild 2: Einstellungen für das Projekt<\/span><\/b><\/p>\n Sie haben nun schon an zwei Stellen gelesen, dass Eigenschaften nirgends erscheinen. Das ist ein Unterschied zu COM-DLLs, bei denen die hier angegebenen Informationen zum Beispiel im Verweise-Dialog erscheinen. Wo und wie Sie den Namen für das COM-Add-In für den VBA-Editor einstellen und wo es dann erscheint, lesen Sie weiter unten.<\/p>\n Wenn Sie das Modul HelloWorld.twin <\/b>ansehen, finden Sie eine Klasse vor, welche die Schnittstelle IDTExtensibility2 <\/b>implementiert. Das bedeutet, dass die Class<\/b>-Anweisung den Zusatz Implements IDEXTENSIBILITY2 <\/b>enthält und dass die Klasse alle Elemente dieser Schnittstelle implementieren muss, was bedeutet, dass die in der Klasse enthaltenen Methoden vorliegen müssen (siehe Listing 1).<\/p>\n Listing 1: Aufbau der Klasse des COM-Add-Ins für den VBA-Editor<\/span><\/b><\/p>\n In den Methoden finden Sie zunächst nur jeweils eine MsgBox<\/b>-Anweisung, die nur dazu dient, die grundlegende Funktion des COM-Add-Ins für den VBA-Editor zu demonstrieren, solange Sie noch keine echte Funktionalität eingebaut haben.<\/p>\n Außerdem enthält die Klasse die Deklaration zweier Variablen:<\/p>\n Diese sind noch mit dem Datentyp Object <\/b>ausgestattet, damit das Add-In flexibel mit verschiedenen Hosts eingesetzt werden kann. Wir ersetzen dies gleich, benötigen aber zuvor zwei weitere Verweise. Diese fügen wir im Bereich Settings unter COM Type Library \/ ActiveX References <\/b>zwei neue Verweise hinzu, nämlich Microsoft Visual Basic For Applications Extensibility 5.3 <\/b>und Microsoft Office 16.0 Object Library <\/b>(siehe Bild 3). Anschließend müssen Sie die Änderungen an den Einstellungen speichern, was Sie beispielsweise mit der Tastenkombination Strg + S <\/b>erledigen können.<\/p>\n <\/p>\n Bild 3: Hinzufügen einiger Verweise auf Projektbibliotheken<\/span><\/b><\/p>\n Danach können Sie die Deklaration der beiden Variablen wie folgt ändern:<\/p>\n Diese werden in der Prozedur OnConnection<\/b> gefüllt:<\/p>\n Damit können wir das COM-Add-In nun erstellen. Dazu klicken Sie im Bereich TWINBASIC<\/b> auf die in Bild 4 markierte Schaltfläche.<\/p>\n Bild 4: Erstellen des Projekts<\/span><\/b><\/p>\n Die Ausgabe im Debugging-Bereich sollte danach wie in der gleichen Abbildung aussehen.<\/p>\n Wenn nicht, kann es daran liegen, dass das Projekt nicht kompiliert werden kann oder das noch ein VBA-Editor geöffnet ist, der das bereits erstellte COM-Add-In noch nutzt und dadurch einen Schreibschutz auf die Datei legt.<\/p>\n In letzterem Fall hilft meist das Schließen aller Office-Anwendungen, deren VBA-Editor innerhalb der aktuellen Session bereits einmal geöffnet war.<\/p>\n Danach führen Sie die Datei Register-Addin32.reg <\/b>aus, um die notwendigen Registry-Einträge hinzuzufügen. Das sind nicht alle Einträge – einige Einträge legt bereits twinBASIC beim Erstellen des COM-Add-Ins an. Die Registrierungsdatei enthält lediglich diejenigen, die für das Erkennen des COM-Add-Ins beim Öffnen des VBA-Editors notwendig sind.<\/p>\n Anschließend ist das Add-In registriert und beim Öffnen des VBA-Editors einer beliebigen Office-Anwendung sollten die Meldungsfenster erscheinen, die in den verschiedenen Prozeduren definiert wurden.<\/p>\n Den Inhalt der Registrierungsdatei sehen Sie in Bild 5. Hier sollten Sie noch Anpassungen vornehmen, und zwar für die beiden Eigenschaften FriendlyName <\/b>und Description<\/b>.<\/p>\n Bild 5: Registrierungsdatei für das COM-Add-In für den VBA-Editor<\/span><\/b><\/p>\n Diese beiden tauchen nämlich im Add-In-Manager des VBA-Editors, den Sie mit dem Menüeintrag Add-Ins|Add-In-Manager… <\/b>öffnen, wie in Bild 6 auf. Hier finden Sie die Werte der Eigenschaften FriendlyName <\/b>und Description <\/b>wieder.<\/p>\n Bild 6: Das COM-Add-In im Add-In-Manager des VBA-Editors<\/span><\/b><\/p>\n Falls Sie sich wundern, warum in der Registry-Datei alle Informationen scheinbar doppelt abgebildet werden: Der erste Eintrag ist für den VBA-Editor, der zweite für ein eventuell vorhandes Visual Studio 6.<\/p>\n Nun kommt ein wichtiger Punkt: Bisher gibt es noch keine Gelegenheit, Funktionen des COM-Add-Ins über den VBA-Editor aufzurufen. Dazu fügen wir diesem nun einen Menüeitrag hinzu, mit denen der Benutzer die Funktionen aufrufen kann.<\/p>\n Hier haben wir verschiedene Möglichkeiten. Wir können eine bestehende Symbolleiste verwenden und dieser einen Menüeintrag hinzufügen.<\/p>\n Oder wir fügen diesen zu einem Kontextmenü hinzu. Schließlich können wir auch eine komplett neue Symbolleiste erstellen und diese mit den Befehlen unseres COM-Add-Ins für den VBA-Editor füllen.<\/p>\n Letzteres ist am einfachsten, also schauen wir uns dies zunächst an.<\/p>\n Da Access und die übrigen Office-Programme seit der Version 2007 das Ribbon und Kontextmenüs als Menü verwenden, während Menüleisten und Symbolleisten nur noch vom VBA-Editor genutzt werden, hier noch eine kurze Einordnung der verschiedenen Menüarten im VBA-Editor:<\/p>\n Eine neue Symbolleiste mit einer Schaltfläche müssen wir per VBA-Code hinzufügen. Die benötigten Objekte, Eigenschaften und Befehle stellt die Bibliothek Microsoft Office 16.0 Object Library <\/b>zur Verfügung, die wir bereits weiter oben referenziert haben.<\/p>\n Die notwendigen Anweisungen wollen wir gleich in der Ereignisprozedur OnConnection <\/b>unterbringen, die beim Starten des VBA-Editors als erste der Ereignisprozeduren des COM-Add-Ins für den VBA-Editor aufgerufen wird.<\/p>\n Hier fügen wir als Erstes die Deklaration einer Variablen namens cbr <\/b>mit dem Datentyp CommandBar <\/b>zum Referenzieren der neuen Symbolleiste hinzu:<\/p>\n Danach folgen die beiden Anweisungen zum Speichern der mit den Parametern Application <\/b>und AddInInst <\/b>gelieferten Verweise:<\/p>\n Gerade _VBE <\/b>mit dem Verweis auf den VBA-Editor benötigen wir gleich danach. Falls zuvor bereits eine Symbolleiste mit dem Namen aiuCOMAddIn <\/b>angelegt wurde, wollen wir diese wieder löschen. Da wir nicht wissen, ob diese bereits vorliegt, schalten wir die Fehlerbehandlung vor dem Löschen dieser Symbolleiste aus und rufen dann die Delete<\/b>-Methode für das entsprechende Element der CommandBars<\/b>-Auflistung auf:<\/p>\n Danach legen wir mit der Add<\/b>-Methode der CommandBars<\/b>-Auflistung ein neues Element namens aiuCOM-Add-In <\/b>an, das oben erscheinen soll (msoBarTop<\/b>):<\/p>\n Schließlich fügen wir noch ein neues CommandBarButton<\/b>-Element hinzu. Dazu nutzen wir die Add<\/b>-Methode der Controls<\/b>-Auflistung des CommandBar<\/b>-Objekts und übergeben msoControlButton <\/b>als Typ des anzulegenden Elements:<\/p>\n Danach weisen wir den Text zu, legen eines der eingebauten Icons als Symbol fest und stellen den Stil so ein, dass Icon und Text angezeigt werden. Schließlich soll noch ein ToolTip-Text erscheinen, wenn der Benutzer die Schaltfläche mit der Maus überfährt:<\/p>\n Schließlich machen wir die neue Symbolleiste mit Visible = True <\/b>sichtbar:<\/p>\n Aufmerksame Leser haben gesehen, dass wir die hier verwendete Variable cbb <\/b>für die Schaltfläche noch gar nicht deklariert haben. Das haben wir noch nicht getan, weil diese im allgemeinen Teil der Klasse deklariert werden muss. Außerdem legen wir für diese das Schlüsselwort WithEvents <\/b>fest, damit wir in dieser Klasse auch das durch die Schaltfläche ausgelöste Ereignis implementieren können:<\/p>\n Dieses Ereignis programmieren wir schließlich wie folgt:<\/p>\n Die Prozedur soll lediglich ein Meldungsfenster anzeigen.<\/p>\n Damit ist der Zeitpunkt gekommen, das COM-Add-In für den VBA-Editor auszuprobieren. Dazu speichern Sie die Änderungen und betätigen die Build<\/b>-Schaltfläche. Wenn der Debugging-Bereich die erfolgreiche Erstellung anzeigt, starten Sie danach Access und öffnen den VBA-Editor.<\/p>\n Die neue Symbolleiste erscheint dann etwa wie in Bild 7. Wenn Sie diese anklicken, zeigt der VBA-Editor die angegebene Meldung an.<\/p>\n Bild 7: Die neue Symbolleiste samt Befehl<\/span><\/b><\/p>\n Etwas komplizierter wird es, wenn Sie eine Symbolleiste zu einer bestehenden Symbolleiste hinzufügen wollen. Der VBA-Editor enthält nämlich eine ganze Reihe von CommandBar-Elementen. Diese können wir mit der folgenden Prozedur, die wir einfach in ein Modul einer Access-Datenbank eintragen, ermitteln:<\/p>\n Dies liefert das Ergebnis aus Bild 8 – auch unsere soeben erstellte Symbolleiste wird hier aufgeführt.<\/p>\n Bild 8: Ausgabe der CommandBar-Elemente<\/span><\/b><\/p>\n Aber sind das alles Symbolleisten Nein, denn wir finden hier auch einen Eintrag namens Menüleiste<\/b>.<\/p>\n Und es sind gegebenenfalls auch Kontextmenüs darunter. Also ermitteln wir das etwas genauer und geben jeweils die über die Eigenschaft Type <\/b>ermittelte Art mithilfe der Choose<\/b>-Funktion übersetzt aus:<\/p>\n Nun sehen wir wie in Bild 9, dass die Anzahl der Symbolleisten überschaubar ist und wir durchaus die richtige auf diese einfache Weise ermitteln können. Bei den Kontextmenüs sind die Bezeichnungen auch durchaus aussagekräftig – diese benötigen wir allerdings erst im nächsten Abschnitt.<\/p>\n Bild 9: Ausgabe aller CommandBar-Elemente mit Typ<\/span><\/b><\/p>\n Die Namen der Symbolleisten hätten Sie übrigens auch einfacher ermitteln können – indem Sie den Menüeintrag Ansicht|Symbolleisten <\/b>aufrufen.<\/p>\n Dieser zeigt alle Symbolleisten in einem weiteren Untermenü zur Auswahl an (siehe Bild 10).<\/p>\n Bild 10: Anzeige der Symbolleisten<\/span><\/b><\/p>\n Da wir nun die Namen aller Kontextmenüs ermittelt haben, können wir eine auswählen, der wir eine Schaltfläche hinzufügen wollen. Wir entscheiden uns für die standardmäßig angezeigte Symbolleiste Voreinstellung<\/b>. Dafür legen wir zunächst eine neue Variable für die Schaltfläche an und eine entsprechende Ereignisprozedur:<\/p>\n Außerdem fügen wir der Prozedur OnConnection <\/b>einige weitere Zeilen hinzu:<\/p>\n Damit erhalten wir eine weitere Schaltfläche, diesmal in einer bereits existierenden Symbolleiste (siehe Bild 11).<\/p>\n Bild 11: Schaltfläche in eingebauter Symbolleiste<\/span><\/b><\/p>\n Auf diese Weise können Sie beliebig viele Steuerelemente zu neuen oder vorhandenen Symbolleisten hinzufügen.<\/p>\n Wenn Sie einem Kontextmenü einen Eintrag hinzufügen möchten, benötigen Sie zuerst einmal den Namen des betroffenen Kontextmenüs. Dieser ist nicht so leicht zu finden wie bei den Symbolleisten und es gibt auch noch eine größere Anzahl Kontexmenüs.<\/p>\n Allerdings haben wir die Bezeichnungen ja weiter oben bereits im Direktbereich des VBA-Editors ausgeben lassen. Damit lässt sich leicht darauf schließen, in welchem Kontext ein Kontextmenü beim Klick mit der rechten Maustaste angezeigt wird.<\/p>\n Wir wollen einen Eintrag hinzufügen, der im Kontextmenü beim Rechtsklick in das Code-Fenster erscheint. Der Name dieses Menüs ist leicht zu finden – er lautet Code Window<\/b>.<\/p>\nEinstellungen anpassen<\/h2>\n
![\"Einstellungen](\"..\/fileadmin\/_temp_\/2021_03\/pic_1307_002.png\")
<\/p>\n\n
Code des COM-Add-Ins für den VBA-Editor<\/h2>\n
Class<\/span> MyVBEAddin\r\n Implements IDTExtensibility2\r\n Private <\/span>_VBE As Object<\/span> ''VBIDE.VBE\r\n Private <\/span>_AddIn As Object<\/span> ''VBIDE.AddIn\r\n \r\n Sub OnConnection(ByVal Application As Object<\/span>, ByVal ConnectMode As <\/span>ext_ConnectMode, ByVal AddInInst As Object<\/span>, _\r\n ByRef custom As Variant<\/span>()) Implements IDTExtensibility2.OnConnection\r\n MsgBox<\/span> \"myVBEAddin.OnConnection\"\r\n Set<\/span> _VBE = Application\r\n Set<\/span> _AddIn = AddInInst\r\n End Sub\r\n \r\n Sub OnDisconnection(ByVal RemoveMode As <\/span>ext_DisconnectMode, ByRef custom As Variant<\/span>()) _\r\n Implements IDTExtensibility2.OnDisconnection\r\n MsgBox<\/span> \"myVBEAddin.OnDisconnection\"\r\n End SUb\r\n \r\n Sub OnAddInsUpdate(ByRef custom As Variant<\/span>()) Implements IDTExtensibility2.OnAddInsUpdate\r\n MsgBox<\/span> \"myVBEAddin.OnAddInsUpdate\"\r\n End SUb\r\n \r\n Sub OnStartupComplete(ByRef custom As Variant<\/span>()) Implements IDTExtensibility2.OnStartupComplete\r\n MsgBox<\/span> \"myVBEAddin.OnStartupComplete\"\r\n End Sub\r\n \r\n Sub OnBeginShutdown(ByRef custom As Variant<\/span>()) Implements IDTExtensibility2.OnBeginShutdown\r\n MsgBox<\/span> \"myVBEAddin.OnBeginShutdown\"\r\n End Sub\r\nEnd Class<\/span><\/pre>\nPrivate <\/span>_VBE As Object<\/span> ''VBIDE.VBE\r\nPrivate <\/span>_AddIn As Object<\/span> ''VBIDE.AddIn<\/pre>\n![\"Hinzufügen](\"..\/fileadmin\/_temp_\/2021_03\/pic_1307_004.png\")
<\/p>\nPrivate <\/span>_VBE As <\/span>VBIDE.VBE\r\nPrivate <\/span>_AddIn As <\/span>VBIDE.AddIn<\/pre>\nSub <\/span>OnConnection(ByVal Application As Object<\/span>, _\r\n ByVal ConnectMode As <\/span>ext_ConnectMode, _\r\n ByVal AddInInst As Object<\/span>, _\r\n ByRef custom As Variant<\/span>()) _\r\n Implements IDTExtensibility2.OnConnection\r\n MsgBox<\/span> \"myVBEAddin.OnConnection\"\r\n Set<\/span> _VBE = Application\r\n Set<\/span> _AddIn = AddInInst\r\nEnd Sub<\/span><\/pre>\nErstellen des COM-Add-Ins für den VBA-Editor<\/h2>\n
![\"Erstellen](\"..\/fileadmin\/_temp_\/2021_03\/pic_1307_005.png\")
<\/p>\nRegistrieren des COM-Add-Ins für den VBA-Editor<\/h2>\n
![\"Registrierungsdatei](\"..\/fileadmin\/_temp_\/2021_03\/pic_1307_003.png\")
<\/p>\n![\"Das](\"..\/fileadmin\/_temp_\/2021_03\/pic_1307_006.png\")
<\/p>\nMenüeintrag für das COM-Add-In hinzufügen<\/h2>\n
Menüleisten, Symbolleisten und Kontextmenüs<\/h2>\n
\n
Neue Symbolleiste mit neuer Schaltfläche erstellen<\/h2>\n
Sub <\/span>OnConnection(ByVal Application As Object<\/span>, _\r\n ByVal ConnectMode As <\/span>ext_ConnectMode, _\r\n ByVal AddInInst As Object<\/span>, _\r\n ByRef custom As Variant<\/span>()) _\r\n Implements IDTExtensibility2.OnConnection\r\n Dim <\/span>cbr As <\/span>CommandBar<\/pre>\n Set<\/span> _VBE = Application\r\n Set<\/span> _AddIn = AddInInst<\/pre>\n On Error Resume Next<\/span>\r\n _VBE.CommandBars(\"aiuCOMAddIn\").Delete\r\n On Error Goto 0<\/pre>\n Set<\/span> cbr = _VBE.CommandBars.Add(\"aiuCOMAddIn\", msoBarTop)<\/pre>\n Set<\/span> cbb = cbr.Controls.Add(msoControlButton)<\/pre>\n cbb.Style = msoButtonIconAndCaption\r\n cbb.Caption=\"aiuBeispiel\"\r\n cbb.FaceId = 67\r\n cbb.ToolTipText = \"Beispiel-Button eines COM-Add-Ins\"<\/pre>\n
cbr.Visible = True<\/span>\r\nEnd Sub<\/span><\/pre>\nPrivate <\/span>WithEvents cbb As <\/span>CommandBarButton<\/pre>\nPrivate Sub <\/span>cbb_Click(_\r\n ByVal Ctrl As <\/span>Office.CommandBarButton, _\r\n CancelDefault As Boolean<\/span>)\r\n MsgBox<\/span> \"Click\"\r\nEnd Sub<\/span><\/pre>\nMenüschaltfläche testen<\/h2>\n
![\"Die](\"..\/fileadmin\/_temp_\/2021_03\/pic_1307_007.png\")
<\/p>\nSchaltfläche zu bestehender Symbolleiste hinzufügen<\/h2>\n
Public Sub <\/span>AlleSymbolleisten()\r\n Dim <\/span>cbr As <\/span>CommandBar\r\n For Each cbr In VBE.CommandBars\r\n Debug.Print<\/span> cbr.Name\r\n Next<\/span> cbr\r\nEnd Sub<\/span><\/pre>\n![\"Ausgabe](\"..\/fileadmin\/_temp_\/2021_03\/pic_1307_008.png\")
<\/p>\nPublic Sub <\/span>AlleSymbolleisten()\r\n Dim <\/span>cbr As <\/span>CommandBar\r\n For Each cbr In VBE.CommandBars\r\n Debug.Print<\/span> Choose(cbr.Type + 1, \"Symbolleiste\", \"Menüleiste\", \"Kontextmenü\"), cbr.Name\r\n Next<\/span> cbr\r\nEnd Sub<\/span><\/pre>\n![\"Ausgabe](\"..\/fileadmin\/_temp_\/2021_03\/pic_1307_009.png\")
<\/p>\n![\"Anzeige](\"..\/fileadmin\/_temp_\/2021_03\/pic_1307_010.png\")
<\/p>\nSchaltfläche zu bestehendem Kontextmenü hinzufügen<\/h2>\n
Private <\/span>WithEvents cbb1 As <\/span>CommandBarButton\r\nPrivate Sub <\/span>cbb1_Click( ByVal Ctrl As <\/span>Office.CommandBarButton, CancelDefault As Boolean<\/span>)\r\n MsgBox<\/span> \"Click aus einer eingebauten Symbolleiste\"\r\nEnd Sub<\/span><\/pre>\nSub <\/span>OnConnection(...) Implements IDTExtensibility2.OnConnection\r\n ...\r\n Set<\/span> cbr = _VBE.CommandBars(\"Voreinstellung\")\r\n On Error Resume Next<\/span>\r\n cbr.Controls(\"aiuBeispiel1\").Delete\r\n On Error Goto 0\r\n Set<\/span> cbb1 = cbr.Controls.Add(msoControlButton)\r\n cbb1.Caption = \"aiuBeispiel1\"\r\n cbb1.BeginGroup = True<\/span>\r\n cbb1.FaceID = 68\r\n cbb1.Style=msoButtonIconAndCaption\r\n cbb1.ToolTipText = \"Beispiel-Button in eingebauter Symbolleiste\"\r\nEnd Sub<\/span><\/pre>\n![\"Schaltfläche](\"..\/fileadmin\/_temp_\/2021_03\/pic_1307_011.png\")
<\/p>\nEinträge zu Kontextmenüs hinzufügen<\/h2>\n
![\"Der](\"..\/fileadmin\/_temp_\/2021_03\/pic_1307_012.png\")
<\/p>\n