{"id":55000433,"date":"2024-08-01T00:00:00","date_gmt":"2024-08-14T14:44:35","guid":{"rendered":"http:\/\/access-im-unternehmen.aix-dev.de\/aiu\/?p=433"},"modified":"-0001-11-30T00:00:00","modified_gmt":"-0001-11-30T00:00:00","slug":"Klassenprogrammierung_mit_COMAddIn_vereinfachen","status":"publish","type":"post","link":"https:\/\/vbentwickler.de\/Klassenprogrammierung_mit_COMAddIn_vereinfachen\/","title":{"rendered":"Klassenprogrammierung mit COM-Add-In vereinfachen"},"content":{"rendered":"

\"\"<\/p>\n

\"Menüeintrag<\/p>\n

Bild 1: Menüeintrag unseres COM-Add-Ins<\/span><\/b><\/p>\n

Im Artikel “VBA-Editor: Klasseneigenschaften per Mausklick” (www.vbentwickler.de\/422) haben wir eine Prozedur vorgestellt, mit denen man aus einer einfachen Variablendeklaration innerhalb eines Klassenmoduls eine private Membervariable und jeweils eine Property Get-Methode und eine Property Set\/Let-Methode erzeugen kann. Der einzige Haken bei dieser Lösung ist, dass man diese bisher noch über den Direktbereich aufrufen musste. Da das nicht sonderlich komfortabel ist, stellen wir in diesem Artikel eine Lösung vor, bei der wir mit twinBASIC ein COM-Add-In für den VBA-Editor erstellen, mit dem wir die Funktion aus dem oben genannten Artikel über die Menüleiste, die Symbolleiste oder auch über das Kontextmenü des VBA-Editors aufrufen kann. <\/b><\/p>\n

Wir bauen hier auf den Vorbereitungen auf, die wir im Artikel twinBASIC: COM-Add-In für den VBA-Editor <\/b>(www.vbentwickler.de\/421<\/b>) vorgestellt haben. Hier haben wir ein Basis-COM-Add-In für den VBA-Editor vorgestellt, das einfach nur ein paar Dummy-Einträge im Menü und im Kontextmenü anzeigt, die Meldungsfenster liefern. Den ersten sehen wir in Bild 1.<\/p>\n

\"Menüeintrag<\/p>\n

Bild 1: Menüeintrag unseres COM-Add-Ins<\/span><\/b><\/p>\n

Den zweiten Eintrag, den wir im Kontextmenü untergebracht haben, finden wir im Kontextmenü in Bild 2 ganz unten.<\/p>\n

\"Menüeintrag<\/p>\n

Bild 2: Menüeintrag im Kontextmenü<\/span><\/b><\/p>\n

In der Symbolleiste haben wir noch keinen Eintrag untergebracht. Auch das wollen wir gegebenenfalls noch erledigen. Erst einmal schauen wir uns jedoch die zu programmierende Funktion an – wo im Menü wir diese optimal unterbringen.<\/p>\n

Umwandeln von Variablen in Property Get\/Let\/Set<\/h2>\n

Die Aufgabe lautet, die Prozedur, die wir im oben genannten Artikel entwickelt haben, über ein COM-Add-In für den VBA-Editor verfügbar zu machen. Diese Aufgabe ist einfach – wir brauchen eigentlich nur unsere Menüpunkte umzubenennen und diesen den Aufruf der gewünschten Prozedur hinzuzufügen.<\/p>\n

Allerdings wollen wir das mit Bedacht tun, damit wir den bestmöglichen Ort für den Menüeintrag finden. Es geht darum, eine oder mehrere Variablen im Code eines Klassenmoduls zu markieren und dann die Prozedur VariableToProperty <\/b>aufzurufen. Diese holt sich die aktuelle Markierung und passt den gefundenen Code entsprechend an.<\/p>\n

Um diese Funktion nach dem Selektieren der zu bearbeitenden Code-Passagen aufzurufen: Was wäre der geeignete Ort? Wir wollen mit möglichst wenig Klicks und möglichst wenig Mausmetern zum Ziel kommen. Wenn wir also einen Eintrag im Menü verwenden, sollte dieser direkt erreichbar sein. Dazu bietet sicher eher die Symbolleiste an, in der wir den Befehl über ein geeignetes Icon anbieten können. Allerdings muss man für eine solche erklärungsbedürftige Aufgabe erst einmal ein passendes Icon finden.<\/p>\n

Die zweite Möglichkeit ist, diesen Befehl in der Menüleiste selbst unterzubringen. Hier sollten wir allerdings keine Befehle in der Hauptmenüleiste unterbringen, sondern vielleicht einen Hauptmenüpunkt unterbringen, der nicht nur diesen, sondern gegebenenfalls noch andere Einträge mit Aufrufen unserer selbst definierten Funktionen enthält. Die Struktur mit Mein Menü|Mein Befehl <\/b>ist daher schon passend. Damit wären wir nach dem Markieren der zu bearbeitenden Codezeilen mit zwei Mausklicks am Ziel.<\/p>\n

Die nächste Möglichkeit ist das Kontextmenü. Hier benötigen wir grundsätzlich einen Klick mehr, weil wir diese erst einmal mit einem Rechtsklick anzeigen müssen. Wenn wir den Befehl dann direkt im Kontextmenü anzeigen, kommen wir schnell zum Ziel. Wenn das Kontextmenü noch keine Einträge weiterer COM-Add-Ins enthält, kann man das so machen. Wenn wir jedoch planen, noch weitere benutzerdefinierte Funktionen zu diesem oder anderen COM-Add-Ins hinzuzufügen, können wir auch einen Unterpunkt hinzufügen.<\/p>\n

Das wäre dann zwar ein Mausklick mehr, aber letztlich sparen wir durch die Funktion an sich schon so viel Zeit, dass sich das nicht besonders auswirken sollte.<\/p>\n

Also starten wir wie folgt:<\/p>\n

    \n
  • Wir fügen der Menüleiste einen Menüpunkt beispielsweise namens AMV-Tools <\/b>hinzu. Unter diesem legen wir den Aufruf zum Umwandeln der Variablen in Property Get<\/b>\/Let<\/b>\/Set<\/b>-Prozeduren an.<\/li>\n
  • Wir fügen auch dem Kontextmenü einen Menüpunkt namens AMV-Tools <\/b>hinzu. Dieser enthält wiederum eine Schaltfläche zum Aufrufen der gewünschten Funktion.<\/li>\n
  • Schließlich wollen wir den Befehl auch noch in der Symbolleiste unterbringen. Hier können wir den Befehl direkt unterbringen, sollten uns jedoch auf ein Icon beschränken.<\/li>\n
  • Außerdem fügen wir die gewünschte Funktion zum Umwandeln von Variablen in Propertys hinzu und testen diese ausführlich.<\/li>\n<\/ul>\n

    Passende Symbolleiste finden<\/h2>\n

    Der VBA-Editor enthält einige Symbolleisten. Welche verwenden wir optimalerweise für unsere Funktion? Schauen wir uns erst einmal an, welche eingebauten Symbolleisten der VBA-Editor alle anbietet. Dazu lassen wir in einer VBA-Anwendung die folgende Prozedur laufen:<\/p>\n

    Public Sub <\/span>ListMenus()\r\n     Dim <\/span>cbr As <\/span>Office.CommandBar\r\n     For Each cbr In VBE.CommandBars\r\n         If <\/span>cbr.Type = msoBarTypeNormal Then<\/span>\r\n             Debug.Print<\/span> cbr.Name\r\n         End If<\/span>\r\n     Next<\/span> cbr\r\nEnd Sub<\/span><\/pre>\n
    Dies liefert das folgende Ergebnis:<\/p>\n
    Voreinstellung\r\nBearbeiten\r\nDebuggen\r\nUserForm\r\nClipboard<\/pre>\n
    Wenn wir uns diese Symbolleisten einmal anschauen, können wir besser entscheiden, welche der richtige Ort ist. Dazu blenden wir einmal alle Symbolleisten ein. Das erledigen wir über den Menüpunkt Ansicht|Symbolleisten<\/b>. Hier finden wir alle verfügbaren Symbolleisten vor – wobei aus der per VBA ausgegebenen Liste der Eintrag Clipboard<\/b> fehlt. Dafür finden wir einen zusätzlichen Eintrag namens Anpassen…<\/b> (siehe Bild 3).<\/p>\n
    \"Einblenden<\/p>\n
    Bild 3: Einblenden aller Symbolleisten<\/span><\/b><\/p>\n
    Die eingeblendeten Symbolleisten erscheinen zunächst freischwebend, was normalerweise nicht erwünscht ist – außer, man benötigt die entsprechende Funktion direkt in der Nähe der damit zu bearbeitenden Elemente. Dann stellt sich jedoch die Frage, ob der Einsatz eines Kontextmenüs nicht ohnehin die bessere Lösung wäre.<\/p>\n
    Für unseren Zweck scheint uns jedenfalls die Symbolleiste Bearbeiten <\/b>am geeignetsten zu sein. Also fügen die unseren Befehl dort hinzu.<\/p>\n
    Einfügen eines Befehls in der Bearbeiten-Symbolleiste und mehr<\/h2>\n
    Nun schauen wir uns an, wie wir die im Artikel twinBASIC: COM-Add-In für den VBA-Editor <\/b>(www.vbentwickler.de\/421<\/b>) vorgestellte Vorlage genau anpassen, um unsere Funktionen im VBA-Editor bereitzustellen. Wir gehen an dieser Stelle nicht mehr auf alle dort beschriebenen Details ein.<\/p>\n
    Um die Menüs mit unseren Schaltflächen zu füllen, benötigen wir zuerst einmal die Prozedur, die beim Verbinden des VBA-Editors mit dem COM-Add-In ausgelöst wird.<\/p>\n
    Diese weist der Objektvariablen objVBE<\/b>, die wir öffentlich in einem Modul namens mdlGlobal<\/b> definieren, den mit dem Parameter Application<\/b> gelieferten Verweis auf die aufrufende Anwendung zu:<\/p>\n
    Public <\/span>objVBE As <\/span>VBIDE.VBE<\/pre>\n
    Außerdem rufen wir in dieser Prozedur, die in Listing 1 abgebildet ist, die Prozedur CreateToolbar <\/b>auf.<\/p>\n
    Sub <\/span>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     Set<\/span> objVBE = Application\r\n     Set<\/span> objAddIn = AddInInst\r\n     isConnected = True<\/span>\r\n     CreateToolBar()\r\nEnd Sub<\/span><\/pre>\n
    Listing 1: Diese Prozedur wird beim Verbinden des COM-Add-Ins ausgelöst.<\/span><\/b><\/p>\n
    Diese referenziert zuerst die Menüleiste mit der Variablen cbr <\/b>und fügt dieser ein Untermenü hinzu (siehe Listing 2). Dieses platziert sie vor dem achten Untermenü, stellt die Beschriftung auf den Wert aus der Konstanten cStrMenu <\/b>ein (AMV-Tools<\/b>) und fügt diesem ein mit der Variablen cbb <\/b>referenziertes CommandBarButton<\/b>-Element hinzu.<\/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     Set<\/span> cbr = objVBE.CommandBars(\"Menüleiste\") ''Eintrag in Menüleiste anlegen\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> cbbMenu =.Controls.Add(msoControlButton, Temporary:=True<\/span>)\r\n     End With<\/span>\r\n     With<\/span> cbbMenu\r\n         .Caption = cStrCommandButton\r\n         .BeginGroup = True<\/span>\r\n         .Picture = GetImage(\"GetSet.png\")\r\n         Set<\/span> cbbMenuEvent = objVBE.Events.CommandBarEvents(cbbMenu)\r\n     End With<\/span>\r\n     Set<\/span> cbr = objVBE.CommandBars(\"Bearbeiten\") ''Eintrag in Symbolleiste ''Bearbeiten'' anlegen\r\n     Set<\/span> cbbToolbar = cbr.Controls.Add(msoControlButton, temporary:=True<\/span>)\r\n     With<\/span> cbbToolbar\r\n         .BeginGroup = True<\/span>\r\n         .Picture = GetImage(\"GetSet.png\")\r\n         Set<\/span> cbbToolbarEvent = objVBE.Events.CommandBarEvents(cbbToolbar)\r\n     End With<\/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     Set<\/span> cbbContext = cbpContext.Controls.Add(Temporary:=True<\/span>)\r\n     With<\/span> cbbContext\r\n         .Caption = cStrCommandButton\r\n         .Picture = GetImage(\"GetSet.png\")\r\n         .BeginGroup = True<\/span>\r\n         Set<\/span> cbbContextEvent = objVBE.Events.CommandBarEvents(cbbContext)\r\n     End With<\/span>\r\nEnd Sub<\/span><\/pre>\n
    Listing 2: Diese Prozedur erstellt die CommandBarButton-Objekte in den verschiedenen Menüs.<\/span><\/b><\/p>\n
    Für dieses legt es die Beschriftung aus der Konstanten cStrCommandButton <\/b>fest (Getter und Setter für Variable<\/b>) und stellt das Icon mit der Picture<\/b>-Eigenschaft auf das Ergebnis der Funktion GetImage <\/b>mit dem Parameter GetSet.png <\/b>ein. Schließlich weisen wir der Objektvariablen cbbMenuEvent <\/b>die Ereignisse des CommandBarButton<\/b>-Objekts zu.<\/p>\n
    Die Objektvariablen für die Menüs deklarieren wir im allgemeinen Teil des Menüs wie folgt:<\/p>\n
    Private <\/span>cbbToolbar As <\/span>CommandBarButton\r\nPrivate <\/span>cbbMenu As <\/span>CommandBarButton\r\nPrivate <\/span>cbbContext As <\/span>CommandBarButton<\/pre>\n
    Direkt danach folgen die Deklarationen der Event-Klassen für die drei anzulegenden Schaltflächen:<\/p>\n
    Private <\/span>WithEvents cbbToolbarEvent As <\/span>_\r\n     VBIDE.CommandBarEvents\r\nPrivate <\/span>WithEvents cbbContextEvent As <\/span>_\r\n     VBIDE.CommandBarEvents\r\nPrivate <\/span>WithEvents cbbMenuEvent As <\/span>VBIDE.commandbarEvents<\/pre>\n
    Damit legen wir nun den Eintrag in der Symbolleiste an. Dazu referenzieren wir die Symbolleiste Bearbeiten<\/b> mit der Variablen cbr<\/b>. Dieser fügen wir ein neues Element hinzu und referenzieren es mit cbbToolbar<\/b>. Dieses erhält keine Beschriftung, aber ebenfalls das Icon. Außerdem referenzieren wir seine Ereignisse mit der Variablen cbbToolbarEvent<\/b>.<\/p>\n
    Schließlich folgt noch der Eintrag im Kontextmenü. Dazu referenzieren wir das Kontextmenü mit dem Namen Code Window<\/b> und weisen diesem ein neues Untermenü hinzu, das wir mit der Variablen cbpContext<\/b> referenzieren und das wie das Untermenü in der Menüleiste die Beschriftung aus cStrMenu <\/b>erhält.<\/p>\n
    Diesem Untermenü fügen wir eine Schaltfläche hinzu, die genauso aufgebaut ist wie die im Hauptmenü. Wir referenzieren sie aber mit der Variablen cbbContext <\/b>und seine Events mit der Variablen cbbContextEvent<\/b>.<\/p>\n
    Damit haben wir alle Menüeintrage hinzugefügt. Nun müssen wir die Ereignisprozeduren definieren.<\/p>\n
    Ereignisse für die drei Menübefehle programmieren<\/h2>\n
    Dazu wählen wir im Codefenster von twinBASIC jeweils oben im mittleren Auswahlfeld den Namen des Klassenmoduls aus und im rechten dann den Eintrag Click (siehe Bild 4).<\/p>\n
    \"Anlegen<\/p>\n
    Bild 4: Anlegen der Ereignisprozeduren für die Menübuttons<\/span><\/b><\/p>\n
    Dies legt die drei Ereignisprozeduren an, die wir wie in Listing 3 füllen. Diese rufen jeweils die Prozedur LaunchFunction <\/b>auf und stellen die Parameter handled <\/b>auf True <\/b>und CancelDefault <\/b>auf False <\/b>ein.<\/p>\n
    Private Sub <\/span>cbbMenuEvent_Click(ByVal CommandBarControl As Object<\/span>, handled As Boolean<\/span>, CancelDefault As Boolean<\/span>)\r\n     LaunchFunction\r\n     handled = True<\/span>\r\n     CancelDefault = False<\/span>\r\nEnd Sub<\/span>\r\nPrivate Sub <\/span>cbbToolbarEvent_Click(ByVal CommandBarControl As Object<\/span>, handled As Boolean<\/span>, CancelDefault As Boolean<\/span>)\r\n     LaunchFunction\r\n     handled = True<\/span>\r\n     CancelDefault = False<\/span>\r\nEnd Sub<\/span>\r\nPrivate Sub <\/span>cbbContextEvent_Click(ByVal CommandBarControl As Object<\/span>, handled As Boolean<\/span>, CancelDefault As Boolean<\/span>)\r\n     LaunchFunction\r\n     handled = True<\/span>\r\n     CancelDefault = False<\/span>\r\nEnd Sub<\/span><\/pre>\n
    Listing 3: Ereignisprozeduren für die Menüschaltflächen<\/span><\/b><\/p>\n
    Die Prozedur LaunchFunction <\/b>sieht wie folgt aus und ruft lediglich mit der Call<\/b>-Anweisung die Prozedur VariableToProperty <\/b>auf:<\/p>\n
    Public Sub <\/span>LaunchFunction()\r\n     Call<\/span> VariableToProperty()\r\nEnd Sub<\/span><\/pre>\n
    Diese wiederum erledigt die eigentliche Arbeit. Da wir die Prozedur bereits im Artikel VBA-Editor: Klasseneigenschaften per Mausklick<\/b> (www.vbentwickler.de\/422<\/b>) ausführlich beschrieben haben, gehen wir hier nur auf die wenigen Änderungen ein, die für den Betrieb in unserem COM-Add-In notwendig sind.<\/p>\n
    In der Prozedur VariableToProperty <\/b>ist nur die folgende Änderung notwendig:<\/p>\n
    Public Sub <\/span>VariableToProperty()\r\n     ...\r\n     Set<\/span> objCodePane = objVBE.ActiveCodePane ''objVBE statt VBE\r\n     ...\r\nEnd Sub<\/span><\/pre>\n
    Damit läuft das COM-Add-In wie gewünscht und wir können es bereits einmal erstellen. Dazu rufen wir im COM-Add-In den Befehl File|Build <\/b>auf. Mit dem Beispielprojekt aus dem Download sollte das Erstellen problemlos durchlaufen.<\/p>\n
    Danach kannst Du eine Office-Anwendung öffnen und mit Alt + F11 <\/b>den VBA-Editor anzeigen. Hier kannst Du die Funktion des COM-Add-Ins nun über drei Möglichkeiten aufrufen.<\/p>\n
    Die erste ist die Menüleiste, also das Hauptmenü des VBA-Editors. Hier finden wir den Befehl in einem eigenen Untermenü namens AMV-Tools <\/b>unter dem Namen Getter und Setter für Variable<\/b> (siehe Bild 5).<\/p>\n
    \"Aufruf<\/p>\n
    Bild 5: Aufruf des COM-Add-Ins über die Menüleiste<\/span><\/b><\/p>\n
    Die zweite ist der Aufruf über die Symbolleiste Bearbeiten<\/b>. Hier haben wir an letzter Stelle unseren Befehl mit dem Icon mit der Beschriftung Get\/Set <\/b>hinzugefügt (siehe Bild 6). Dieser ruft die gleiche Funktion auf.<\/p>\n
    \"Aufruf<\/p>\n
    Bild 6: Aufruf des COM-Add-Ins per Symbolleiste<\/span><\/b><\/p>\n
    Schließlich finden wir den Befehl auch noch im Kontextmenü. Hier haben wir ebenfalls ein Untermenü namens AMV-Tools <\/b>vorgeschaltet (siehe Bild 7).<\/p>\n
    \"Aufruf<\/p>\n
    Bild 7: Aufruf des COM-Add-Ins per Kontextmenüleiste<\/span><\/b><\/p>\n
    Dieser Ansatz geht davon aus, dass wir unter dem Menü AMV-Tools <\/b>noch weitere Funktionen über dieses oder andere COM-Add-Ins einbauen.<\/p>\n
    Wenn das nicht der Fall ist, können wir den Befehl auch einzeln ohne das Untermenü im Kontextmenü anzeigen lassen. Den letzten Teil, in dem wir das Untermenü und den Befehl im Kontextmenü anlegen, ersetzen wir nun durch die folgenden Anweisungen:<\/p>\n
    Set<\/span> cbr = objVBE.CommandBars(\"Code Window\")\r\nSet<\/span> cbbContext = cbr.Controls.Add(Temporary:=True, _\r\n      Before:=6)\r\nWith<\/span> cbbContext\r\n     .Caption = cStrCommandButton\r\n     .Picture = GetImage(\"GetSet.png\")\r\n     .BeginGroup = True<\/span>\r\n     Set<\/span> cbbContextEvent = _\r\n        objVBE.Events.CommandBarEvents(cbbContext)\r\nEnd With<\/span><\/pre>\n
    Durch den Parameter Before<\/b> in der Add<\/b>-Methode sorgen wir dafür, dass der Befehl direkt hinter den beiden Befehlen Block auskommentieren <\/b>und Auskommentierung des Blocks aufheben <\/b>erscheint (siehe Bild 8).<\/p>\n
    \"Aufruf<\/p>\n
    Bild 8: Aufruf des COM-Add-Ins direkt über das Kontextmenü<\/span><\/b><\/p>\n
    Damit können wir nun wie in den vorherigen Screenshots gezeigt eine Zeile mit einer Variablendeklaration markieren, die wir in eine private Variable mit Getter- und Setter umwandeln wollen (siehe Bild 9).<\/p>\n
    \"Ergebnis<\/p>\n
    Bild 9: Ergebnis der Funktion<\/span><\/b><\/p>\n
    Das COM-Add-In aus dem Download für eigene Zwecke nutzen<\/h2>\n
    Wenn Du das COM-Add-In auf Deinem eigenen Rechner für den Einsatz im VBA-Editor installieren möchtest, sind ein paar Handgriffe nötig.<\/p>\n
    Als Erstes kopierst Du die für Deine Office-Version passende Version in einen Ordner Deiner Wahl – also für die 32-Bit- oder die 64-Bit-Version.<\/p>\n
    Beide Varianten findest Du im Download:<\/p>\n