<\/p>\n
Im Beitrag „COM-Add-In für den VBA-Editor“ haben wir uns zunächst darum gekümmert, überhaupt eine COM-DLL zu programmieren und diese so in die Registry einzutragen, dass sie beim Starten des VBA-Editors geladen wird und die dort angelegten Ereignisprozeduren ausgelöst wurden. Damit sind wir noch lange nicht fertig. Im vorliegenden Artikel schauen wir uns an, wie Sie dem VBA-Editor Menüeinträge für den Aufruf der im COM-Add-In enthaltenen Funktionen hinzufügen – und zwar für die Menüleiste, die Symbolleiste sowie für Kontextmenüs.<\/b><\/p>\nVorbereitung<\/h2>\n
Als Vorbereitung für die Beispiele dieses Artikels führen Sie die Schritte aus dem Artikel COM-Add-In für den VBA-Editor <\/b>oder verwenden das dort enthaltene Beispielprojekt als Ausgangspunkt. Wir haben das Projekt einfach neu erstellt, und zwar unter dem Namen COMAddInMenues<\/b>, und eine neue Registrierungsdatei namens COMAddInMenues.reg <\/b>und eine neue GUID erzeugt, die wir an den entsprechenden Stellen eingefügt haben (also in der .reg<\/b>-Datei und über der Connect<\/b>-Klasse). Achten Sie auch darauf, den Namen COMAddInMenues<\/b> an den entsprechenden Stellen der .reg<\/b>-Datei einzufügen. Die Datei sieht für das neue Add-In wie in Listing 1 aus.<\/p>\n Listing 1: Inhalt der Datei für die Registry<\/span><\/b><\/p>\n Das Ladeverhalten stellen wir gleich auf den Wert 3 <\/b>ein, damit das Add-In beim Starten des VBA-Editors aufgerufen wird und wir das Ladeverhalten nicht erst noch im Add-In-Manager anpassen müssen.<\/p>\n Die übrigen Schritte wie das Hinzufügen der Verweise und die benötigten Einstellungen haben wir im Artikel COM-Add-In für den VBA-Editor <\/b>beschrieben.<\/p>\n Denken Sie vor dem Erstellen des Projekts immer daran, Visual Studio im Administrator-Modus zu öffnen, da das COM-Add-In sonst nicht erstellt werden kann.<\/p>\n Bevor wir eigene Menüpunkte anlegen können, wollen wir uns zunächst ansehen, wie wir überhaupt auf die Menüs des VBA-Editors zugreifen können.<\/p>\n Die Menüs und die für den Zugriff benötigten Objekte wie die CommandBars<\/b>-Auflistung und das CommandBar<\/b>-Objekt sowie deren untergeordnete Elemente und Eigenschaften sind Bestandteil der Office-Bibliothek. Diese fügen Sie über den Verweis-Manager hinzu, indem Sie nach dem Schlüsselwort Office <\/b>suchen und dann den Eintrag aus Bild 1 auswählen.<\/p>\n Bild 1: Hinzufügen eines Verweises auf die Office-Bibliothek<\/span><\/b><\/p>\n Außerdem importieren wir den passenden Namespace in die Klasse Connect.vb<\/b>:<\/p>\n Die Befehle, die sich beim Start des COM-Add-Ins mit den Menüeinträgen befassen, wollen wir gleich in eine eigene Prozedur auslagen. Diese rufen wir gleich beim Start des COM-Add-Ins in der Methode OnConnection <\/b>auf:<\/p>\n Als Erstes wollen wir einfach die Auflistung der CommandBar<\/b>-Elemente durchlaufen und diese in Meldungsfenstern ausgeben. Dazu füllen wir die Prozedur CommandBarsAusgeben <\/b>wie folgt:<\/p>\n Diese Prozedur verwendet die bereits beim Laden des COM-Add-Ins mit einem Verweis auf das Objekt VBE <\/b>gefüllte Member-Variablen _VBE<\/b>. VBE <\/b>steht stellvertretend für das Objektmodell des VBA-Editors.<\/p>\n Diese stellt unter anderem die Auflistung CommandBars <\/b>bereit, die alle CommandBar<\/b>-Elemente des VBA-Editors enthält. Die Variable cbrs <\/b>mit dem Typ CommandBars <\/b>füllen wir mit einem Verweis auf die CommandBars<\/b>-Auflistung des VBE<\/b>-Objekts. In einer For Each<\/b>-Schleife durchlaufen wir dann alle Elemente dieser Auflistung und geben den Namen des aktuellen Elements in einer Meldung aus.<\/p>\n Das ist allerdings nicht wirklich komfortabel – immerhin gibt es einige Menüs in der Auflistung CommandBars<\/b>. Wir wollen diese lieber in Visual Studio ausgeben, statt für jedes Menü ein neues Meldungsfenster zu öffnen. Wenn wir in Visual Studio den Menüeintrag Debuggen|Debugging starten… <\/b>wählen, führt dies allerdings zur Meldung aus Bild 2.<\/p>\n Bild 2: Fehlermeldung beim Versuch, das Projekt zu debuggen<\/span><\/b><\/p>\n Um dies zu ändern, müssen wir in den Eigenschaften des Projekts eine Anwendung festlegen, die zusammen mit dem Add-In gestartet wird. Das Add-In selbst ist nämlich keine ausführbare Datei. Wir wollen das Add-In mit dem VBA-Editor unter Access testen, also legen wir Access als Startanwendung fest.<\/p>\n Dazu öffnen Sie die Eigenschaften des Projekts und wechseln dort zum Bereich Debuggen<\/b>. Hier wählen Sie unter Projekt starten <\/b>die Option Externes Programm starten <\/b>aus und wählen über den mit der Schaltfläche Durchsuchen… <\/b>zu öffnenden Dialog die Datei MSAccess.Exe <\/b>aus (siehe Bild 3).<\/p>\n Bild 3: Startanwendung festlegen<\/span><\/b><\/p>\n Danach können Sie mit dem Menübefehl Debuggen|Debugging starten <\/b>das Debuggen beginnen. Visual Studio startet dann Microsoft Access und wird, wenn Sie den VBA-Editor von Access aus aufrufen, die für das Laden des Add-Ins bestimmten Ereignisse auslösen. Sie können nun also beispielsweise Haltepunkte im Code platzieren und den Code so schrittweise durchlaufen. Beenden Sie das Debugging von Visual Studio aus, wird die gestartete Instanz von Visual Studio ebenfalls beendet.<\/p>\n Gegebenenfalls stoßen Sie dabei auf eine Fehlermeldung, dass die DLL nicht erzeugt werden konnte. Dies kann der Fall sein, wenn Sie bereits zuvor den VBA-Editor für eine Anwendung geöffnet haben und diese die bestehende DLL referenziert hat. Visual Studio kann diese dann nicht neu erstellen.<\/p>\n Wenn wir den Befehl in der Schleife wie folgt ändern, erhalten wir die Liste aller Menüs des VBA-Editors wie in Bild 4:<\/p>\n Bild 4: Ausgabe der Menüs des VBA-Editors<\/span><\/b><\/p>\n Nun erweitern wir die Schleife so, dass auch noch die Steuer-elemente eines jeden Menüs ausgeben werden. Dazu deklarieren wir eine Variable für die Steuer-elemente mit dem Typ CommandBarControl<\/b>:<\/p>\n In der Schleife fügen wir eine weitere Schleife über alle Elemente der Controls<\/b>-Auflistung hinzu und geben die enthaltenen Elemente ebenfalls im Direktbereich von Visual Studio aus:<\/p>\n Für den Eintrag Menüleiste <\/b>sieht das Ergebnis etwa wie folgt aus:<\/p>\n Genau genommen handelt es sich hierbei gar nicht um Schaltflächen, sondern um Untermenüs, die wiederum Control-Elemente enthalten – hier finden sich dann die eigentlichen Befehle.<\/p>\n Eine weitere Schleife wollen wir nun nicht mehr unterbringen, das System sollte nun verständlich sein.<\/p>\n Wir können nun eigenen Menüs hinzufügen, bestehenden Menüs neue Untermenüs zuweisen oder auch bestehenden und neuen Menüs neue Steuer-elemente zuweisen. In der Regel werden wir jedoch neue Steuer-elemente zu bestehenden Menüs hinzufügen, um diese um die Funktionen des COM-Add-Ins zu erweitern.<\/p>\n Dazu müssen wir zunächst einmal herausfinden, welchem Menü wir unseren Befehl hinzufügen wollen. In diesem Fall wollen wir, da wir ja noch keinen konkreten Anwendungszweck haben, einfach einmal einen Befehl zum Menüpunkt Add-Ins <\/b>hinzufügen.<\/p>\n Damit es nicht zu leicht wird, soll dieses Menü noch ein Untermenü erhalten, dem wir dann unsere Schaltfläche hinzufügen. Gerade beim Auflisten des eingebauten Menüs namens Menüleiste <\/b>haben wir ja bereits den Namen ermittelt.<\/p>\n Diesen können wir nun zum Referenzieren des entsprechenden CommandBar<\/b>-Elements verwenden. Darunter finden wir das Untermenü namens Add-&Ins<\/b>, das wir ebenfalls referenzieren. Schließlich legen wir darin mit der Add<\/b>-Methode der Controls<\/b>-Auflistung ein neues Unterelement des Typs msoControlPopup<\/b> an, was dem Untermenü entspricht, und weisen diesem die Beschriftung Mein Add-In <\/b>zu.<\/p>\n Außerdem soll vor diesem Untermenü ein Trennstrich eingefügt werden, was wir mit dem Wert True <\/b>für die Eigenschaft BeginGroup <\/b>erreichen:<\/p>\n <\/p>\n Den Aufruf dieser Methode fügen wir schließlich noch der Ereignismethode OnStartupComplete <\/b>zu:<\/p>\n Danach starten wir das Projekt, was automatisch Access öffnet, und laden dann eine Datenbank, für die wir den VBA-Editor öffnen. Das Add-Ins-Menü sieht dann nach dem Aufklappen wie in Bild 5 aus. Dieses zeigt dann natürlich noch keine Befehle an, da wir noch keine hinzugefügt haben.<\/p>\n Bild 5: Unser neues Untermenü<\/span><\/b><\/p>\n Die Schaltfläche zum Ausführen eines benutzerdefinierten Befehls fügen wir nun hinzu. Dazu deklarieren wir zunächst eine Variable namens cbc <\/b>mit dem Typ CommandBarButton <\/b>in der Methode SteuerelementHinzufuegen<\/b>. Diese fügen wir über die Add<\/b>-Methode der Controls<\/b>-Auflistung des soeben erstellten Untermenüs aus cbrSub <\/b>hinzu und legen dabei den Typ des Steuerelements auf msoControlButton <\/b>fest. Schließlich füllen wir die Eigenschaft Caption <\/b>mit dem Wert Meine Schaltfläche<\/b>:<\/p>\n Die Schaltfläche erscheint nun so wie in Bild 6.<\/p>\n Bild 6: Neue Schaltfläche im Untermenü<\/span><\/b><\/p>\n Nun soll die Schaltfläche auch noch eine Aufgaben ausführen – in diesem Fall beispielsweise einfach das Anzeigen eines Meldungsfensters. Dazu müssen wir irgendwie festlegen, dass wir für das mit cbc <\/b>deklarierte Element Ereignisse implementieren können.<\/p>\n Dazu versehen wir die Deklaration der Variablen mit dem zusätzlichen Schlüsselwort WithEvents<\/b>.<\/p>\n Eine solche Deklaration ist allerdings innerhalb einer Methode unzulässig, die Variable muss daher unabhängig von der Methode deklariert werden. Wir verschieben die folgende Zeile daher in den allgemeinen Teil der Klasse:<\/p>\n Das Anlegen der Ereignisprozedur, die beim Anklicken des Menüeintrags ausgelöst wird, legen wir nun auch auf einfache Weise an.<\/p>\n Dazu wählen Sie im mittleren Kombinationsfeld oben im Codefenster den Eintrag cbc<\/b> aus und selektieren dann im rechten Kombinationsfeld den Eintrag für die gewünschte Ereignismethode – in diesem Fall gibt es nur eine einzige Auswahlmöglichkeit, nämlich Click <\/b>(siehe Bild 7).<\/p>\n Bild 7: Anlegen der neuen Ereignisprozedur<\/span><\/b><\/p>\n Wenn Sie das Add-In nun neu starten und im VBA-Editor die Schaltfläche betätigen, erscheint die gewünschte Meldung.<\/p>\n Im ersten Beispiel haben wir das Hauptmenü des VBA-Editors erweitert. Sie können aber auch die Symbolleisten, die in Zusammenhang mit den verschiedenen Elementen des VBA-Editors eingeblendet werden, erweitern. Hier ist es dann unter anderem sinnvoll, eine entsprechende Icon-Datei bereitzustellen, denn in Symbolleisten wird – wie der Name schon sagt – ein Symbol statt eines Textes dargestellt.<\/p>\n Dummerweise ist es relativ kompliziert, das mit benutzerdefinierten Icon-Dateien zu erledigen, denn das CommandBarButton<\/b>-Element weist gleich zwei Eigenschaften zum Festlegen des Bildes auf: Die erste heißt Picture<\/b>, die zweite Mask<\/b>. Die erste enthält das Bild, die zweite eine Maske, die festlegt, welche Teile aus Picture <\/b>transparent angezeigt werden. Praktischerweise können wir uns mit ein paar Codezeilen die notwendigen Werkzeuge bauen, die wir für das Erstellen des Picture<\/b>– und des Mask<\/b>-Elements aus einer handelsüblichen .png<\/b>-Datei benötigen.<\/p>\n Dazu fügen wir zunächst noch weitere Verweise zum Projekt hinzu, und zwar die folgenden:<\/p>\n Danach fügen Sie dem Projekt eine neue Klasse namens IconConverter<\/b> hinzu, die wie folgt aussehen soll:<\/p>\n Außerdem benötigen wir die folgende Methode, die wir zur Klasse Connect.vb <\/b>hinzufügen können:<\/p>\n Diese liefert die Maske zu einer Bilddatei, die wir mit dem Parameter img <\/b>übergeben.<\/p>\n Die Bilddatei fehlt noch. Um diese hinzuzufügen, öffnen wir in den Eigenschaften des Projekts den Bereich Ressourcen<\/b>.<\/p>\n Hier klicken Sie auf die Schaltfläche mit dem Pfeil nach unten rechts neben der Schaltfläche Ressource hinzufügen <\/b>und öffnen so ein Menü, in dem Sie den Befehl Vorhandene Datei hinzufügen… <\/b>auswählen (siehe Bild 8).<\/p>\n Bild 8: Hinzufügen einer vorhandenen Datei<\/span><\/b><\/p>\n Wählen Sie dann die gewünschte Bilddatei aus – beispielsweise eine .png<\/b>-Datei mit einer Größe von 16×16. Diese erscheint nach dem Hinzufügen wie in Bild 9 im Ressourcen-Editor.<\/p>\n Bild 9: Die neue Bilddatei<\/span><\/b><\/p>\n Bevor wir eine Schaltfläche zu einer der Symbolleisten hinzufügen, wollen wir das Bild der bereits erstellten Schaltfläche im Untermenü des Eintrags Add-Ins <\/b>des Hauptmenüs hinzufügen.<\/p>\n Dazu erweitern wir die Methode SteuerelementHinzufuegen <\/b>wie folgt. Dazu legen wir eine neue Variable namens objBitmap <\/b>mit dem Datentyp Bitmap <\/b>an. In der Definition des Steuerelements in der Variablen cbc <\/b>ermitteln wir dann mit der Methode GetObject <\/b>und dem Parameter add <\/b>das Bild, das in der Ressourcendatei Images <\/b>gespeichert ist. Dann ermitteln wir mit der Methode GetIPictureDispFromImage <\/b>der Klasse IconConverter <\/b>ein Objekt des Typs IPictureDisp <\/b>– dies ist das Format, das die beiden Eigenschaften Picture <\/b>und Mask <\/b>erwarten – und weisen es der Eigenschaft Picture <\/b>zu.<\/p>\n Das IPictureDisp<\/b>-Objekt für die Eigenschaft Mask <\/b>ermitteln wir mit der Funktion GetPictureMask<\/b> (siehe Listing 2).<\/p>\n Listing 2: Prozedur zum Hinzufügen eines Steuerelements<\/span><\/b><\/p>\n Damit wollen wir nun auch noch eine Schaltfläche zu einer der Symbolleisten hinzufügen. Dazu lassen wir uns zuerst einmal alle Namen der Symbolleisten ausgeben. Dazu passen wir die Methode CommandBarsAusgeben <\/b>so an, dass diese nur die Namen der Symbolleisten ausgibt. Diese haben den Typ msoBarTypeNormal<\/b>:<\/p>\n Dies liefert die folgenden Elemente:<\/p>\n Wir wollen einen Eintrag zur Symbolleiste Bearbeiten <\/b>hinzufügen. Dazu definieren wir zunächst wieder eine Variable für die zu erstellende Schaltfläche:<\/p>\n Leider müssen wir für jede Schaltfläche eine neue Objektvariable mit dem Schlüsselwort WithEvents <\/b>erstellen, da wir sonst nicht für jede Schaltfläche eine eigene Ereignisprozedur anlegen können. Die Methode, mit der wir die Schaltfläche zur Symbolleiste hinzufügen, sieht wie in Listing 3 aus.<\/p>\n Listing 3: Prozedur zum Hinzufügen eines Steuerelements zu einer Symbolleiste<\/span><\/b><\/p>\n Nach dem Ausführen des Add-Ins sieht das Ergebnis im VBA-Editor wie in Bild 10 aus. Damit wollen wir uns noch nicht zufriedengeben, denn die Schaltfläche wirkt dort hinten doch etwas verloren. Also wollen wir diese weiter links positionieren, beispielsweise zwischen den Schaltflächen für Entwurfsmodus und Projekt-Explorer. Aber mit welcher Eigenschaft können wir dies einstellen Genau genommen gelingt dies nicht per Eigenschaft, sondern Sie geben die Position als Parameter der Add<\/b>-Methode der Controls<\/b>-Auflistung mit auf den Weg.<\/p>\n Bild 10: Neue Schaltfläche in der Symbolleiste<\/span><\/b><\/p>\n Der Parameter heißt Before<\/b> und erwartet den Index des Steuer-element, vor dem das neue Steuer-element eingefügt werden soll. Wir müssen also zuvor den Index der Schaltfläche Projekt-Explorer <\/b>ermitteln und diesen dann als Wert des Parameters Before <\/b>übergeben.<\/p>\n Zur Sicherheit prüfen wir noch, wie die Symbolleiste tatsächlich aufgebaut ist und wie die korrekte Bezeichnung lautet. Dazu fügen wir in der Methode CommandBarsAusgeben <\/b>wieder die folgenden drei Zeilen in die vorhandene For Each<\/b>-Schleife ein, um auch die Steuer-elemente der durchlaufenen Symbolleisten auszugeben:<\/p>\n Dies liefert das Ergebnis aus Bild 11. Allerdings taucht hier an der für uns interessanten Stelle noch ein weiterer Eintrag namens &Projekt ausführen <\/b>auf.<\/p>\n Bild 11: Namen der Steuer-elemente der Symbolleiste Voreinstellungen<\/span><\/b><\/p>\n Warum sehen wir den nicht in der Symbolleiste Ganz einfach: Weil er ausgeblendet ist. Das prüfen wir, indem wir die Debug.Print<\/b>-Anweisung noch wie folgt anpassen und erhalten hier den Wert False<\/b>:<\/p>\n Danach sieht unsere Methode SteuerelementHinzufuegenSymbolleiste <\/b>wie folgt aus:<\/p>\n Wir ermitteln also zunächst einen Verweis namens cbcBefore <\/b>auf die Schaltfläche, vor der wir unsere Schaltfläche einfügen möchten. Dann ermitteln wir über die Eigenschaft Index <\/b>ihren Index und speichern diesen in der Variablen intBefore<\/b>.<\/p>\n Der Add<\/b>-Methode der Controls<\/b>-Auflistung fügen wir dann über den Parameter Before <\/b>den Index aus intBefore <\/b>zu. Nach dem Erstellen stellen wie schließlich noch die Eigenschaften ToolTipText<\/b> und BeginGroup <\/b>ein, sodass unsere Symbolleiste nach dem nächsten Start des VBA-Editors wie in Bild 12 aussieht. Das Erstellen der Ereignismethode für das Click<\/b>-Ereignis sparen wir an dieser Stelle – Sie wissen ja bereits, wie das gelingt.<\/p>\n Bild 12: Die neue Schaltfläche an der gewünschten Position und mit ToolTipText<\/span><\/b><\/p>\n Fehlt noch ein Beispiel dafür, wie Sie einen Eintrag zu einem Kontextmenü hinzufügen können. Dazu listen wir zunächst einmal alle Kontextmenüs des VBA-Editors auf.<\/p>\n Dazu geben wir wieder alle Kontextmenüs im Direktbereich von Visual Studio aus. Um dies zu erledigen, kopieren wir die Methode CommandBarsAusgeben <\/b>in die Methode PopupMenusAusgeben <\/b>und ersetzen den Parameter msoBarTypeNormal <\/b>durch msoBarTypePopup<\/b>.<\/p>\n Außerdem fügen wir den Aufruf dieser Methode der Methode OnStartupComplete <\/b>zu. Nach dem nächsten Start des VBA-Editors werden die Namen aller Kontextmenüs im Direktfenster von Visual Studio ausgegeben. Das sind eine ganze Menge – daher wird es schwierig, das richtige Menü zu finden.<\/p>\n Um uns die Arbeit zu erleichtern, fügen wir einfach jedem Kontextmenü eine Schaltfläche an, die den Namen des Kontextmenüs enthält. So können wir dann schnell das gewünschte Kontextmenü identifizieren.<\/p>\n Dazu haben wir in der folgenden Methode, die alle Kontextmenüs durchläuft, für jedes Kontextmenü eine neue Schaltfläche hinzugefügt, der wir für die Caption<\/b>-Eigenschaft den Namen des Menüs hinzugefügt haben. Außerdem haben wir jeweils den Beginn einer neuen Gruppe für die neuen Einträge definiert:<\/p>\nWindows Registry Editor Version 5.00\r\n[HKEY_CURRENT_USER\\Software\\Microsoft\\VBA\\VBE\\6.0\\Addins\\COMAddInMenues.Connect]\r\n\"CommandLineSafe\"=dword:00000000\r\n\"Description\"=\"Grundgerüst für ein COM-Add-In für den VBA-Editor\"\r\n\"LoadBehavior\"=dword:00000003\r\n\"FriendlyName\"=\"COMAddInMenues\"\r\n[HKEY_CLASSES_ROOT\\WOW6432Node\\CLSID\\{ABA0B519-CB8C-4A03-9815-D99DFE3312C9}]\r\n@=\"COMAddInMenues.Connect\"\r\n[HKEY_CLASSES_ROOT\\WOW6432Node\\CLSID\\{ABA0B519-CB8C-4A03-9815-D99DFE3312C9}\\Implemented Categories]\r\n[HKEY_CLASSES_ROOT\\WOW6432Node\\CLSID\\{ABA0B519-CB8C-4A03-9815-D99DFE3312C9}\\InprocServer32]\r\n@=\"mscoree.dll\"\r\n\"ThreadingModel\"=\"Both\"\r\n\"Class\"=\"COMAddInMenues.Connect\"\r\n\"Assembly\"=\"COMAddInMenues\"\r\n\"RuntimeVersion\"=\"v2.0.50727\"\r\n\"CodeBase\"=\"file:\/\/\/C:\\...\\COMAddInMenues.dll\"\r\n[HKEY_CLASSES_ROOT\\WOW6432Node\\CLSID\\{ABA0B519-CB8C-4A03-9815-D99DFE3312C9}\\ProgId]\r\n@=\"COMAddInMenues.Connect\"<\/pre>\nZugriff auf die eingebauten Menüs<\/h2>\n
![\"Hinzufügen](\"..\/fileadmin\/_temp_\/2019_01\/pic_1177_001.png\")
<\/p>\nImports Microsoft.Office.Core<\/pre>\n
Public Sub <\/span>OnConnection(Application As Object<\/span>, _\r\n ConnectMode As <\/span>ext_ConnectMode, _\r\n AddInInst As Object<\/span>, _\r\n ByRef custom As <\/span>Array) _\r\n Implements IDTExtensibility2.OnConnection\r\n _VBE = DirectCast(Application, VBE)\r\n _AddIn = DirectCast(AddInInst, AddIn)\r\n Select Case ConnectMode\r\n Case <\/span>Extensibility.ext_ConnectMode.ext_cm_Startup\r\n CommandBarsAusgeben()\r\n End Select<\/span>\r\nEnd Sub<\/span><\/pre>\nPrivate Sub <\/span>CommandBarsAusgeben()\r\n Dim <\/span>cbrs As <\/span>CommandBars\r\n Dim <\/span>cbr As <\/span>CommandBar\r\n cbrs = _VBE.CommandBars\r\n For Each cbr In cbrs\r\n MessageBox.Show(cbr.Name)\r\n Next<\/span>\r\nEnd Sub<\/span><\/pre>\nDebuggen des Add-Ins<\/h2>\n
![\"Fehlermeldung](\"..\/fileadmin\/_temp_\/2019_01\/pic_1177_002.png\")
<\/p>\n![\"Startanwendung](\"..\/fileadmin\/_temp_\/2019_01\/pic_1177_003.png\")
<\/p>\n![\"Ausgabe](\"..\/fileadmin\/_temp_\/2019_01\/pic_1177_004.png\")
<\/p>\nFor Each cbr In cbrs\r\n Debug.Print<\/span>(cbr.Name)\r\nNext<\/span><\/pre>\nDim <\/span>cbc As <\/span>CommandBarControl<\/pre>\nFor Each cbr In cbrs\r\n Debug.Print<\/span>(cbr.Name)\r\n For Each cbc In cbr.Controls\r\n Debug.Print<\/span>(\" \" + cbc.Caption)\r\n Next<\/span>\r\nNext<\/span><\/pre>\nMenüleiste\r\n &Datei\r\n &Bearbeiten\r\n ...\r\n Add-&Ins\r\n &Fenster\r\n &<\/pre>\n
Menü hinzufügen oder nur Steuerelemente<\/h2>\n
Steuerelement hinzufügen<\/h2>\n
Private Sub <\/span>SteuerelementHinzufuegen()\r\n Dim <\/span>cbr As <\/span>CommandBar\r\n Dim <\/span>cbrAddIns As <\/span>CommandBarPopup = Nothing\r\n Dim <\/span>cbrSub As <\/span>CommandBarPopup = Nothing\r\n cbr = _VBE.CommandBars(\"Menüleiste\")\r\n cbrAddIns = cbr.Controls.Item(\"Add-&Ins\")\r\n cbrSub = cbrAddIns.Controls.Add(MsoControlType. msoControlPopup)\r\n With<\/span> cbrSub\r\n .Caption = \"Mein Add-In\"\r\n .BeginGroup = True<\/span>\r\n End With<\/span>\r\nEnd Sub<\/span><\/pre>\nPublic Sub <\/span>OnStartupComplete(ByRef custom As <\/span>Array) Implements IDTExtensibility2.OnStartupComplete\r\n SteuerelementHinzufuegen()\r\nEnd Sub<\/span><\/pre>\n![\"Unser](\"..\/fileadmin\/_temp_\/2019_01\/pic_1177_005.png\")
<\/p>\nSchaltfläche zum Untermenü hinzufügen<\/h2>\n
Private Sub <\/span>SteuerelementHinzufuegen()\r\n ...\r\n Dim <\/span>cbc As <\/span>CommandBarButton = Nothing\r\n ...\r\n With<\/span> cbrSub\r\n ...\r\n cbc = .Controls.Add(MsoControlType.msoControlButton)\r\n With<\/span> cbc\r\n .Caption = \"Meine Schaltfläche\"\r\n End With<\/span>\r\n End With<\/span>\r\nEnd Sub<\/span><\/pre>\n![\"Neue](\"..\/fileadmin\/_temp_\/2019_01\/pic_1177_006.png\")
<\/p>\nSchaltfläche mit Funktion versehen<\/h2>\n
Dim <\/span>WithEvents cbc As <\/span>CommandBarButton = Nothing<\/pre>\n![\"Anlegen](\"..\/fileadmin\/_temp_\/2019_01\/pic_1177_009.png\")
<\/p>\nPrivate Sub <\/span>cbc_Click(Ctrl As <\/span>CommandBarButton, ByRef CancelDefault As Boolean<\/span>) Handles cbc.Click\r\n MessageBox.Show(\"Klick auf meinen Menübefehl\")\r\nEnd Sub<\/span><\/pre>\nSymbolleisten<\/h2>\n
\n
Imports System.Windows.Forms\r\nPublic Class<\/span> IconConverter\r\n Inherits AxHost\r\n Private <\/span>Sub New()\r\n MyBase.New(String.Empty)\r\n End Sub\r\n Public <\/span>Shared Function GetIPictureDispFromImage(ByVal image As <\/span>System.Drawing.Image) As <\/span>stdole.IPictureDisp\r\n Return CType(GetIPictureDispFromPicture(image), stdole.IPictureDisp)\r\n End Function\r\nEnd Class<\/span><\/pre>\nPrivate Function <\/span>GetPictureMask(ByVal img As <\/span>Bitmap) As <\/span>stdole.IPictureDisp\r\n Dim <\/span>c As <\/span>Color\r\n For y As Integer<\/span> = 0 To img.Height - 1\r\n For x As Integer<\/span> = 0 To img.Width - 1\r\n c = img.GetPixel(x, y)\r\n Dim <\/span>m As <\/span>Color = Color.Empty\r\n If <\/span>c.B = 0 AndAlso c.R = 0 AndAlso c.G = 0 Then<\/span>\r\n m = Color.White\r\n Else<\/span>\r\n m = Color.Black\r\n End If<\/span>\r\n img.SetPixel(x, y, Color.FromArgb(c.A, m.R, m.G, m.B))\r\n Next<\/span>\r\n Next<\/span>\r\n Return IconConverter.GetIPictureDispFromImage(img)\r\nEnd Function<\/span><\/pre>\n![\"Hinzufügen](\"..\/fileadmin\/_temp_\/2019_01\/pic_1177_007.png\")
<\/p>\n![\"Die](\"..\/fileadmin\/_temp_\/2019_01\/pic_1177_010.png\")
<\/p>\nPrivate Sub <\/span>SteuerelementHinzufuegen()\r\n Dim <\/span>icon As <\/span>Bitmap\r\n ...\r\n With<\/span> cbrSub\r\n ...\r\n cbc = .Controls.Add(MsoControlType.msoControlButton)\r\n With<\/span> cbc\r\n .Caption = \"&Meine Schaltfläche\"\r\n icon = My.Resources.Images.ResourceManager.GetObject(\"add\")\r\n .Picture = IconConverter.GetIPictureDispFromImage(icon)\r\n .Mask = GetPictureMask(icon)\r\n End With<\/span>\r\n End With<\/span>\r\nEnd Sub<\/span><\/pre>\nPrivate Sub <\/span>CommandBarsAusgeben()\r\n Dim <\/span>cbrs As <\/span>CommandBars\r\n Dim <\/span>cbr As <\/span>CommandBar\r\n cbrs = _VBE.CommandBars\r\n For Each cbr In cbrs\r\n If <\/span>cbr.Type = MsoBarType.msoBarTypeNormal Then<\/span>\r\n Debug.Print<\/span>(cbr.Name)\r\n End If<\/span>\r\n Next<\/span>\r\nEnd Sub<\/span><\/pre>\nVoreinstellung\r\nBearbeiten\r\nDebuggen\r\nUserForm\r\nClipboard<\/pre>\n
Dim <\/span>WithEvents cbcSymbolleiste As <\/span>CommandBarButton<\/pre>\nPrivate Sub <\/span>SteuerelementHinzufuegenSymbolleiste()\r\n Dim <\/span>cbr As <\/span>CommandBar\r\n Dim <\/span>objBitmap As <\/span>Bitmap\r\n cbr = _VBE.CommandBars(\"Voreinstellung\")\r\n cbcSymbolleiste = cbr.Controls.Add(MsoControlType.msoControlButton)\r\n With<\/span> cbcSymbolleiste\r\n objBitmap = My.Resources.ResourceManager.GetObject(\"add\")\r\n .Picture = IconConverter.GetIPictureDispFromImage(objBitmap)\r\n .Mask = GetPictureMask(objBitmap)\r\n End With<\/span>\r\nEnd Sub<\/span><\/pre>\n![\"Neue](\"..\/fileadmin\/_temp_\/2019_01\/pic_1177_011.png\")
<\/p>\nFor Each cbc In cbr.Controls\r\n Debug.Print<\/span>(\" \" + cbc.Caption)\r\nNext<\/span><\/pre>\n![\"Namen](\"..\/fileadmin\/_temp_\/2019_01\/pic_1177_012.png\")
<\/p>\nDebug.Print<\/span>(\" \" + cbc.Caption + \" \" + cbc.Visible.ToString)<\/pre>\nPrivate Sub <\/span>SteuerelementHinzufuegenSymbolleiste()\r\n Dim <\/span>cbr As <\/span>CommandBar\r\n Dim <\/span>cbcBefore As <\/span>CommandBarButton\r\n Dim <\/span>objBitmap As <\/span>Bitmap\r\n Dim <\/span>intBefore As <\/span>Int16\r\n cbr = _VBE.CommandBars(\"Voreinstellung\")\r\n cbcBefore = cbr.Controls.Item(\"&Projekt ausführen\")\r\n intBefore = cbcBefore.Index\r\n cbcSymbolleiste = cbr.Controls.Add( MsoControlType.msoControlButton, Before:=intBefore)\r\n With<\/span> cbcSymbolleiste\r\n objBitmap = My.Resources.ResourceManager. GetObject(\"add\")\r\n .Picture = IconConverter.GetIPictureDispFromImage (objBitmap)\r\n .Mask = GetPictureMask(objBitmap)\r\n .TooltipText = \"Beispielschaltfläche\"\r\n .BeginGroup = True<\/span>\r\n End With<\/span>\r\nEnd Sub<\/span><\/pre>\n![\"Die](\"..\/fileadmin\/_temp_\/2019_01\/pic_1177_013.png\")
<\/p>\nKontextmenüs<\/h2>\n
Private Sub <\/span>PopupMenusAusgeben()\r\n ...\r\n For Each cbr In cbrs\r\n If <\/span>cbr.Type = MsoBarType.msoBarTypePopup