{"id":55000421,"date":"2024-04-01T00:00:00","date_gmt":"2024-04-23T12:48:02","guid":{"rendered":"http:\/\/access-im-unternehmen.aix-dev.de\/aiu\/?p=421"},"modified":"-0001-11-30T00:00:00","modified_gmt":"-0001-11-30T00:00:00","slug":"twinBASIC_COMAddIn_fuer_den_VBAEditor","status":"publish","type":"post","link":"https:\/\/vbentwickler.de\/twinBASIC_COMAddIn_fuer_den_VBAEditor\/","title":{"rendered":"twinBASIC: COM-Add-In für den VBA-Editor"},"content":{"rendered":"

\"\"<\/p>\n

Wer den VBA-Editor mit eigenen Tools erweitern möchte, kommt um die Programmierung von COM-Add-Ins kaum herum – zumindest nicht, wenn er eine schicke Benutzeroberfläche und die Integration in Menüs, Symbolleisten und Kontextmenüs wünscht. In diesem Artikel zeigen wir daher, wie wir die Basis für ein solches COM-Add-In mit twinBASIC programmieren. Ausgehend davon kannst Du direkt loslegen und Deine gewünschten Funktionen einbauen – es sind nur jeweils wenige Anpassung notwendig. Wir erklären Schritt für Schritt, wie die Basis des COM-Add-Ins aufgebaut ist und welche Anpassungen Du vornehmen musst, um ein COM-Add-In für Deine eigenen Anwendungen zu bauen.<\/b><\/p>\n

Start mit Vorlage<\/h2>\n

Für den Start kannst Du das Beispielprojekt VBECOMAddInBasis.twinproj <\/b>aus dem Download zu diesem Artikel verwenden. Diese Datei öffnest Du in der Entwicklungsumgebung twinBASIC, deren jeweils aktuelle Fassung Du unter dem folgenden Link findest:<\/p>\n

https:\/\/github.com\/twinbasic\/twinbasic\/releases<\/pre>\n
Dort klickst Du auf Assets und kannst dann wie in Bild 1 die .zip<\/b>-Datei mit der Entwicklungsumgebung herunterladen. Eine Installation ist nicht notwendig, es reicht das Entpacken im gewünschten Verzeichnis.<\/p>\n
\"Download<\/p>\n
Bild 1: Download der neuesten twinBASIC-Version<\/span><\/b><\/p>\n
Damit kannst Du direkt die Datei VBECOMAddInBasis.twinproj <\/b>öffnen. Diese besteht aus verschiedenen Komponenten, die wir für eine eigene Lösung ändern müssen:<\/p>\n
    \n
  • Code des COM-Add-Ins im Modul MeinComAddIn.twin<\/b>, das die eigentliche Funktionalität enthält<\/li>\n
  • Code des Moduls dllREgistration.twin<\/b>, das den Code für die Registrierung des Tools in der Registry enthält<\/li>\n
  • Eigenschaften im Bereich Settings<\/b>, zum Beispiel um den Projektnamen und Verweise anzupassen<\/li>\n<\/ul>\n
    Code der Hauptklasse<\/h2>\n
    Die Hauptklasse enthält bereits alles, was zum Erstellen eines funktionsfähigen COM-Add-Ins für den VBA-Editor enthält.<\/p>\n
    Im Kopf sehen wir eine ClassId<\/b>, die wir für die Registrierung benötigen. Diese müssen wir jeweils auf eine neue, auf dem jeweiligen System eindeutige GUID anpassen:<\/p>\n
    [ ClassId (\"95FA1EA0-DF9F-4505-A22E-E7CFDCD189\") ]<\/pre>\n
    Darunter beginnt gleich die Klassendefinition. Den Namen der Klasse passen wir, genau wie den Namen des Moduls, auf den gleichen Wert an. Aktuell heißen die Klasse und die Moduldatei MeinComAddIn<\/b>.<\/p>\n
    Die Klasse implementiert die Schnittstelle IDTExtensibility2<\/b>:<\/p>\n
    Class<\/span> MeinComAddIn ''auf eigenes Add-In anpassen\r\n     Implements IDTExtensibility2<\/pre>\n
    Konstanten für das COM-Add-In<\/h2>\n
    Bevor wir diese erläutern, werfen wir einen Blick auf die benötigten Konstanten und Variablen. Hier definieren wir zunächst zwei Konstanten. Die erste enthält den Namen des Hauptmenüpunktes für Dein COM-Add-In, der zweite den Namen des Befehls, der sich in diesem Menü befindet:<\/p>\n
    Private <\/span>Const cStrMenu As String<\/span> = \"Mein Menü\"\r\nPrivate <\/span>Const cStrCommandButton As String<\/span> = \"Mein Befehl\"<\/pre>\n
    Der folgende Code wird dafür sorgen, dass diese beiden Konstanten beim Anlegen der Menübefehls und des Kontextmenü-Eintrags berücksichtigt werden. Der Menübefehl wird dann wie in Bild 2 auftauchen.<\/p>\n
    \"Hier<\/p>\n
    Bild 2: Hier soll der Menübefehl erscheinen.<\/span><\/b><\/p>\n
    Den Kontextmenü-Eintrag finden wir, wenn wir mit der rechten Maustaste in das Code-Fenster klicken (siehe Bild 3).<\/p>\n
    \"Der<\/p>\n
    Bild 3: Der Kontextmenübefehl wird hier eingeblendet.<\/span><\/b><\/p>\n
    Variablen für das COM-Add-In<\/h2>\n
    Für die Basisversion des COM-Add-Ins verwenden wir die folgenden Variablen:<\/p>\n
      \n
    • objVBE<\/b>: Nimmt einen Verweis auf den Visual Basic Editor auf.<\/li>\n
    • objAddIn<\/b>: Referenziert das Add-In.<\/li>\n
    • cbc<\/b>: Referenziert das CommandBarButton<\/b>-Objekt für den Button in der Menüleiste.<\/li>\n
    • cbcContext<\/b>: Referenziert das CommandBarButton<\/b>-Objekt für den Button in der Kontextmenü-Leiste.<\/li>\n
    • cbcEvents<\/b>: Nimmt die Events für den Button in der Menüleiste auf.<\/li>\n
    • cbcEventsContext<\/b>: Nimmt die Events für den Button in der Kontextmenü-Leiste auf.<\/li>\n<\/ul>\n
      Die Deklaration sieht wie folgt aus:<\/p>\n
      Private <\/span>objVBE As <\/span>VBIDE.VBE\r\nPrivate <\/span>objAddIn As <\/span>VBIDE.AddIn\r\nPrivate <\/span>cbc As <\/span>CommandBarButton\r\nPrivate <\/span>cbcContext As <\/span>CommandBarButton\r\nPrivate <\/span>WithEvents cbcEvents As <\/span>VBIDE.CommandBarEvents\r\nPrivate <\/span>WithEvents cbcEventsContext As <\/span>VBIDE.CommandBarEvents<\/pre>\n
      Schließlich benötigen wir noch eine Variable, mit der wir die Information speichern, ob das Add-In geladen ist:<\/p>\n
      Private <\/span>isConnected As Boolean<\/span>   <\/pre>\n
      Beim Laden\/Verbinden des COM-Add-Ins<\/h2>\n
      Weiter oben haben wir geschrieben, dass die Klasse MeinComAddIn <\/b>die Schnittstelle IDTExtensibility2 <\/b>implementiert.<\/p>\n
      Das bedeutet, dass wir einerseits bestimmte Ereignisprozeduren implementieren müssen. Andererseits können wir aber auch sichergehen, dass diese Ereignisprozeduren ausgelöst werden, wenn der VBA-Editor für eine der Office-Anwendungen gestartet wird und unser COM-Add-In in der Registry eingetragen ist.<\/p>\n
      Die erste und wichtigste Prozedur, die dadurch aufgerufen wird, heißt OnConnection<\/b>. Sie sieht wie folgt aus:<\/p>\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     Set<\/span> objVBE = Application\r\n     Set<\/span> objAddIn = AddInInst\r\n     isConnected = True<\/span>\r\n     CreateToolBar()\r\nEnd Sub<\/span><\/pre>\n
      Die Prozedur hat vor allem eine Aufgabe: Einen Verweis auf die Klasse des VBA-Editors entgegenzunehmen, der mit dem Parameter Application<\/b> geliefert wird, und diesen mit der Variablen objVBE <\/b>zu referenzieren.<\/p>\n
      Diese Variable ist der Ausgangspunkt für jegliche Aktionen, die wir im VBA-Editor codegesteuert durch unser Add-In durchführen wollen.<\/p>\n
      Außerdem referenzieren wir noch die Add-In-Instanz selbst, stellen isConnected <\/b>auf True <\/b>ein und rufen die Prozedur CreateToolBar <\/b>auf, die wiederum die Menü- und Kontextmenü-Leisten erstellt.<\/p>\n
      Schaltflächen zu Menü und Kontextmenü hinzufügen<\/h2>\n
      In der Regel wollen wir durch COM-Add-Ins im VBA-Editor Operationen am Code durchführen. Deshalb gehen wir in dieser Basisversion davon aus, dass wir den gleichen Befehl einmal in der Menüleiste und einmal im Kontextmenü hinzufügen wollen. Das erledigen wir mit der Prozedur CreateToolBar<\/b> aus Listing 1.<\/p>\n
      Private Sub <\/span>CreateToolBar()\r\n     Dim <\/span>cbr As <\/span>CommandBar\r\n     Dim <\/span>cbp As <\/span>CommandBarPopup\r\n     Dim <\/span>cbpContext As <\/span>CommandBarPopup\r\n     ''Eintrag in Menüleiste anlegen\r\n     Set<\/span> cbr = objVBE.CommandBars(\"Menüleiste\")\r\n     On Error Resume Next<\/span>\r\n     Set<\/span> cbp = cbr.Controls(cStrMenu)\r\n     On Error GoTo<\/span> 0\r\n     If <\/span>cbp Is Nothing Then<\/span>\r\n         Set<\/span> cbp = cbr.Controls.Add(msoControlPopup, Temporary:=True<\/span>)\r\n         With<\/span> cbp\r\n             .Move Before:=8\r\n             .Caption = cStrMenu\r\n             Set<\/span> cbb =.Controls.Add(msoControlButton, Temporary:=True<\/span>)\r\n         End With<\/span>\r\n     Else<\/span>\r\n         Set<\/span> cbb = cbp.Controls.Add(msoControlButton, temporary:=True<\/span>)\r\n     End If<\/span>\r\n     With<\/span> cbb\r\n         .Caption = cStrCommandButton\r\n         .BeginGroup = True<\/span>\r\n         Set<\/span> cbbEvents = objVBE.Events.CommandBarEvents(cbb)\r\n     End With<\/span>\r\n     ''Eintrag in Kontextmenü anlegen\r\n     On Error Resume Next<\/span>\r\n     Set<\/span> cbpContext = objVBE.CommandBars(\"Code Window\").Controls(cStrMenu)\r\n     On Error GoTo<\/span> 0\r\n     If <\/span>cbpContext Is Nothing Then<\/span>\r\n         Set<\/span> cbpContext = objVBE.CommandBars(\"Code Window\").Controls.Add(msoControlPopup, Temporary:=True<\/span>)\r\n         With<\/span> cbpContext\r\n             .Caption = cStrMenu\r\n         End With<\/span>\r\n     End If<\/span>\r\n     Set<\/span> cbbContext = cbpContext.Controls.Add(Temporary:=True<\/span>)\r\n     With<\/span> cbbContext\r\n         .Caption = cStrCommandButton\r\n         .BeginGroup = True<\/span>\r\n         Set<\/span> cbbEventsContext = objVBE.Events.CommandBarEvents(cbbContext)\r\n     End With<\/span>\r\nEnd Sub<\/span><\/pre>\n
      Listing 1: Hinzufügen von Schaltflächen zu Menüleiste und Kontextmenü<\/span><\/b><\/p>\n
      Die Prozedur deklariert zunächst zwei Untermenü-Elemente namens cbp <\/b>(für das Hauptmenü) und cbpContext <\/b>(für das Kontextmenü) mit dem Typ CommandBarPopup<\/b>.<\/p>\n
      Untermenü referenzieren oder zur Menüleiste hinzufügen<\/h2>\n
      Dann versucht sie, ein eventuell bereits vorhandenes Untermenü mit dem Namen aus cStrMenu<\/b>, in dieser Basisversion also Mein Menü<\/b>, zu referenzieren. Warum das? Weil es sein kann, dass wir bereits mehrere andere COM-Add-Ins in einem Untermenü untergebracht haben, in dem wir die Funktionen all unserer COM-Add-Ins aufrufen wollen. Also versuchen wir bei deaktivierter Fehlerbehandlung, ein solches Untermenü zu referenzieren.<\/p>\n
      Direkt danach prüfen wir, ob dies erfolgreich war – dann wäre cbp <\/b>gefüllt. Falls nicht, erstellen wir das Element mit der Add<\/b>-Methode der Controls<\/b>-Auflistung der Menüleiste neu und referenzieren es mit der Variablen cbp<\/b>. Wir bewegen es mit der Move<\/b>-Methode an die achte Stelle im Menü, also relativ weit nach rechts. Dies kannst Du individuell anpassen.<\/p>\n
      Außerdem stellen wir die Beschriftung über die Caption<\/b>-Eigenschaft auf den Wert aus cStrMenu <\/b>ein, in diesem Fall also Mein Menü<\/b>.<\/p>\n
      Schaltfläche zum Untermenü der Menüleiste hinzufügen<\/h2>\n
      Diesem fügen wir mit der Add<\/b>-Methode der Controls<\/b>-Auflistung eine neue Schaltfläche hinzu und legen für diese die Beschriftung aus der Konstanten cStrCommandButton <\/b>fest, in diesem Fall Mein Befehl<\/b>. Außerdem beginnen wir hier eine neue Gruppe und stellen die Variable cbcEvents <\/b>auf die Events<\/b>-Auflistung für die Schaltfläche ein. Dadurch können wir später für dieses Objekt die Ereignisse der Schaltflächen implementieren.<\/p>\n
      Untermenü und Schaltfläche zum Kontextmenü hinzufügen<\/h2>\n
      Auf ähnliche Weise fügen wir das Untermenü und die Schaltfläche ein. Damit erhalten wir ebenfalls eine Objektvariable namens cbcEventsContext<\/b>, mit der wir das Ereignis beim Anklicken der Schaltfläche implementieren können.<\/p>\n
      Weitere Methoden der IDTExtensibility2-Schnittstelle<\/h2>\n
      Wir programmieren noch weitere Methoden der oben vorgestellten Schnittstelle. Die erste namens OnDisconnection <\/b>ruft die Prozedur ShutdownAddin <\/b>auf:<\/p>\n
      Sub <\/span>OnDisconnection( _\r\n         ByVal RemoveMode As <\/span>ext_DisconnectMode, _\r\n         ByRef custom As Variant<\/span>()) _\r\n         Implements IDTExtensibility2.OnDisconnection\r\n     ShutdownAddin()\r\nEnd Sub<\/span><\/pre>\n
      Die zweite rufe diese ebenfalls auf:<\/p>\n
      Sub <\/span>OnBeginShutdown(ByRef custom As Variant<\/span>()) _\r\n         Implements IDTExtensibility2.OnBeginShutdown\r\n     ShutdownAddin()     \r\nEnd Sub<\/span><\/pre>\n
      Die beiden übrigen Methoden haben keine Funktion, aber wir müssen immer alle Methoden einer Schnittstelle implementieren:<\/p>\n
      Sub <\/span>OnAddInsUpdate(ByRef custom As Variant<\/span>()) _\r\n     Implements IDTExtensibility2.OnAddInsUpdate\r\n                         \r\nEnd Sub<\/span>\r\n                \r\nSub <\/span>OnStartupComplete(ByRef custom As Variant<\/span>()) _\r\n     Implements IDTExtensibility2.OnStartupComplete\r\nEnd Sub<\/span><\/pre>\n
      Beim Herunterfahren des COM-Add-Ins<\/h2>\n
      Gleich zwei der Prozeduren der Schnittstelle IDTExtensibility <\/b>rufen die Prozedur ShutdownAddin <\/b>auf. Diese Prozedur leert die Objektvariablen, damit diese nicht im Speicher verbleiben und auf irgendeine Weise das Entladen des COM-Add-Ins behindern können. Da wir diese Prozedur zur Sicherheit gleich von zwei Prozeduren der Schnittstelle aus aufrufen, setzen wir die Variable isConnected <\/b>nach dem ersten Aufruf auf False<\/b>, damit die Prozedur beim zweiten Aufruf direkt verlassen werden kann:<\/p>\n
      Private Sub <\/span>ShutdownAddin()\r\n     If <\/span>isConnected = False<\/span> Then<\/span>\r\n         Exit Sub<\/span>\r\n     End If<\/span>\r\n     Set<\/span> cbbEvents = Nothing\r\n     Set<\/span> cbb = Nothing\r\n     Set<\/span> cbbEventsContext = Nothing\r\n     Set<\/span> cbbContext = Nothing\r\n     Set<\/span> objAddIn = Nothing\r\n     Set<\/span> objVBE = Nothing\r\n     isConnected = False<\/span>\r\nEnd Sub<\/span><\/pre>\n
      Aufruf der eigentlichen Funktion des COM-Add-Ins<\/h2>\n
      Die Funktion, die wir eigentlich aufrufen wollen, sieht wie folgt aus – und sie soll lediglich zu Testzwecken ein Meldungsfenster anzeigen:<\/p>\n
      Public Sub <\/span>LaunchFunction()\r\n         MsgBox<\/span> \"Mein COM-Add-In\"\r\nEnd Sub<\/span><\/pre>\n
      Aber von wo aus wird diese aufgerufen? Für diesen Zweck implementieren wir die Prozeduren, die durch das Click<\/b>-Ereignis der Objekte aus cbcEvents <\/b>und cbcEventsContext <\/b>aus aufgerufen werden. Diese Prozeduren erhalten vor allem den Parameter CommandBarControl<\/b>. Dieser liefert einen Verweis auf die angeklickte Schaltfläche. Damit können wir beispielsweise den Zustand des aufrufenden Steuerelements ändern. Der zweite Parameter Handled <\/b>kann genutzt werden, wenn mehrere COM-Add-Ins ein Ereignis für ein eingebautes Steuerelement oder auch ein benutzerdefinierte Steuerelement implementieren. Durch das Setzen von Handled <\/b>auf True <\/b>signalisieren wir weiteren Aufrufen, dass das Ereignis bereits behandelt wurde. Der dritte Parameter CancelDefault <\/b>ist für den Fall gedacht, dass wir ein Ereignis für ein eingebautes Steuerelement setzen. Stellen wir diesen Parameter auf True <\/b>ein, wird die eingebaute Funktion durch unsere Funktion ersetzt.<\/p>\n
      Wir wollen in unseren Implementierungen für die Schaltfläche in der Menüleiste und im Kontextmenü vorrangig unsere Prozedur LaunchFunction <\/b>aufrufen:<\/p>\n
      Private Sub <\/span>cbcEvents_Click( _\r\n         ByVal CommandBarControl As Object<\/span>, _\r\n         ByRef Handled As Boolean<\/span>, _\r\n        ByRef CancelDefault As Boolean<\/span>) _\r\n        Handles cbcEvents.Click\r\n     LaunchFunction\r\n     Handled = True<\/span>\r\n     CancelDefault = False<\/span>\r\nEnd Sub<\/span>\r\nPrivate Sub <\/span>cbcEventsContext_Click( _\r\n         ByVal CommandBarControl As Object<\/span>, _\r\n         ByRef Handled As Boolean<\/span>, _\r\n         ByRef CancelDefault As Boolean<\/span>) _\r\n         Handles cbcEventsContext.Click\r\n     LaunchFunction\r\n     Handled = True<\/span>\r\n     CancelDefault = False<\/span>\r\nEnd Sub<\/span><\/pre>\n
      Erstellen eigener COM-Add-Ins für den VBA-Editor auf Basis der Vorlage<\/h2>\n
      Nun wollen wir ein eigenes COM-Add-In erstellen und schauen uns an, welche Änderungen wir dafür im Projekt vornehmen müssen.<\/p>\n
      Als Erstes legen wir dazu eine Kopie der Vorlage VBECOMAddInBasis.twinproj <\/b>unter dem gewünschten Namen an, in diesem Beispiel unter dem Namen EigenesCOMAddIn.twinproj<\/b>.<\/p>\n
      Dann öffnen wir dieses in twinBASIC<\/b> und nehmen die erforderlichen Anpassungen für den Betrieb als eigenes COM-Add-In für den VBA-Editor vor:<\/p>\n