<\/p>\n
Bei unserer Arbeit mit Access passiert es immer wieder, dass wir schnell prüfen wollen, was eine durch ein bestimmtes Ereignis ausgelöste Prozedur überhaupt erledigt. Dann muss man in den Entwurf wechseln, einen Haltepunkt setzen, wieder den Formularansicht aktivieren und dann das Ereignis auslösen. Wir wäre es mit einem Add-In, das die Ereignisse des aktuell markierten Steuerelements direkt anzeigen könnte Ein solches COM-Add-In wollen wir in diesem Beitrag entwickeln und vorstellen. Das ist ein perfekter Anwendungszweck für die neue Entwicklungsumgebung twinBASIC, die wir in Ausgabe 3\/2021 im Detail vorgestellt haben.<\/b><\/p>\nDebuggen schwer gemacht<\/h2>\n
Kennen Sie das auch Sie geben testweise während der Entwicklung einer Anwendung Daten ein oder betätigen eine Schaltfläche, und es geschieht einfach nicht das, was Sie gerade erwarten. Also geht es ans Debuggen: wechseln in die Entwurfsansicht des Formulars, dort das betreffende Steuerelement anklicken, damit seine Eigenschaften im Eigenschaftenblatt erscheinen, die passende Ereignisprozedur auswählen und auf die Schaltfläche mit den drei Punkten klicken (siehe Bild 1).<\/p>\n
![\"Üblicher](\"..\/fileadmin\/_temp_\/2021_04\/pic_1317_002.png\")
<\/p>\n
Bild 1: Üblicher Weg zur Anzeige der Ereignisprozedur eines Steuerelements<\/span><\/b><\/p>\n Der VBA-Editor erscheint und zeigt die durch das Ereignis ausgelöste Prozedur an. Hier setzen wir dann einen Haltepunkt, um den Prozedurablauf gleich im Detail ansehen zu können (siehe Bild 2).<\/p>\n Bild 2: Setzen eines Haltepunktes in der ersten Zeile einer Ereignisprozedur<\/span><\/b><\/p>\n Damit sind die Arbeiten im VBA-Editor vorerst erledigt und wir können zum Access-Fenster zurückkehren. Dort wechseln wir im aktuellen Formular wieder in die Formularansicht und führen den Vorgang erneut aus.<\/p>\n Gegebenenfalls ist es hierzu sogar noch notwendig, das Formular zu schließen und es anschließend über das Ribbon oder von einem anderen Formular aus erneut zu öffnen, damit die benötigte Datenkonstellation wieder vorhanden ist.<\/p>\n Wenn Sie das kennen, wissen Sie: Das ist anstrengend und wirkt irgendwie aufwendiger, als es sein muss. Das haben wir uns auch gedacht und ein COM-Add-In entwickelt, das beim Entwickeln einer Anwendung Folgendes erlaubt: Sie markieren einfach das zu untersuchende Steuerelement und wählen per Ribbon-Befehl aus allen Ereignissen der aktuellen Situation das zu untersuchende aus, welches dann automatisch im VBA-Editor angezeigt wird.<\/p>\n Nun schauen wir uns erst einmal an, was wir am Ende des Beitrags für eine Lösung erhalten. Wenn Sie nach der Installation des COM-Add-Ins ein Steuerelement markieren, können Sie einfach das Ribbon-Menü Ereignisprozeduren anzeigen <\/b>in der Gruppe Steuerelemente <\/b>des Tabs amvAccessTools <\/b>anzeigen. Hier finden Sie ganz oben die Ereignisprozeduren für das aktuelle Hauptformular, in diesem Fall Form_Load<\/b>. Darunter zeigt die Liste für dieses Beispiel die drei Ereignisprozeduren für das Steuerelement ctlTreeView <\/b>(siehe Bild 3).<\/p>\n Bild 3: Anzeige der Ereignisprozedur per Ribbon-Befehl<\/span><\/b><\/p>\n Wählen Sie einen dieser Einträge aus, erscheint der VBA-Editor und die ausgewählte Prozedur wird markiert angezeigt (siehe Bild 4). Wenn Sie ein Steuerelement in einem Unterformular selektieren, werden auch noch die Ereignisprozeduren des Unterformulars in der Liste angezeigt. Für weitere Verschachtelungsebenen ist die Lösung in der hier vorgestellten Form jedoch nicht ausgelegt.<\/p>\n Bild 4: Anzeige und Markierung der Ereignisprozedur<\/span><\/b><\/p>\n Das COM-Add-In programmieren wir mit dem neuen Tool twinBASIC, das wir im Beitrag twinBASIC – VB\/VBA mit moderner Umgebung <\/b>(www.access-im-unternehmen.de\/1303<\/b>) im Detail vorgestellt haben. Hier erfahren Sie auch, wie Sie twinBASIC installieren. Wie Sie ein COM-Add-In grundsätzlich programmieren, beschreibt der Beitrag twinBASIC – COM-Add-Ins für Access <\/b>(www.access-im-unternehmen.de\/1306<\/b>).<\/p>\n Wir starten mit dem aktuellen Beispielprojekt für ein COM-Add-In für Access, das Sie im Download zu diesem Beitrag in der Zip-Datei twinBASIC_myCOMAddin.zip <\/b>finden.<\/p>\n Nachdem Sie Visual Studio Code und twinBASIC wie im oben genannten Beitrag installiert haben, öffnen Sie das Projekt durch einen Doppelklick auf die Datei myCOMAddin.code-workspace<\/b>.<\/p>\n Als Erstes nehmen wir einige Änderungen bezüglich der Benennung von Projekt, Klasse et cetera vor. Dazu öffnen Sie durch einen Mausklick auf den Eintrag Settings <\/b>im Projekt-Explorer die Einstellungen des Projekts.<\/p>\n Hier sehen Sie ganz oben die beiden Einträge Project: Name <\/b>und Project: Description<\/b>. Diese passen Sie wie in Bild 5 an. Wichtig: Merken Sie sich den Namen, den Sie für das Projekt vergeben, hier amvEreignisprozedurAnzeigen<\/b>, – diesen benötigen wir gleich noch. Wichtig: Betätigen Sie auf jeden Fall die Tastenkombination Strg + S<\/b>, um die Änderungen zu speichern!<\/p>\n Bild 5: Anpassen der Benennung von Elementen<\/span><\/b><\/p>\n Dann schauen wir uns die Klasse des Projekts an, was wir durch einen Klick auf den Eintrag HelloWorld.twin <\/b>erreichen. Diesen Eintrag ändern wir, indem wir seinen Kontextmenü-Befehl Umbenennen <\/b>aufrufen und dann etwa die Bezeichnung EreignisprozedurenAnzeigen.twin <\/b>eingeben.<\/p>\n Auch im Code der Klasse stellen wir den Namen wie folgt um:<\/p>\n Schließlich benötigen wir für die nachfolgende Programmierung noch Verweise auf ein paar weitere Bibliotheken. Diese legen wir wieder im Bereich Settings <\/b>an. Hier fügen wir im Bereich COM Type Library \/ ActiveX References <\/b>die beiden folgenden Verweise hinzu:<\/p>\n Der Bereich sollte danach wie in Bild 6 aussehen.<\/p>\n Bild 6: Hinzufügen von Verweisen<\/span><\/b><\/p>\n Die Klasse EreignisprozedurAnzeigen <\/b>enthält nun bereits einige grundlegende Elemente. Zum Beispiel legt die Zeile Implements IDTExtensibility2 <\/b>fest, dass die Klasse die angegebene Schnittstelle implementiert. Das bedeutet, dass wir die für die Schnittstelle vorgegebenen Ereignisprozeduren anlegen müssen.<\/p>\n Die wichtigste Ereignisprozedur ist in unserem Fall OnConnection<\/b>. Wenn Sie Access öffnen, startet es die in der Registry angegebenen COM-Add-Ins (mehr zur Registrierung weiter unten). Dabei wird direkt OnConnection <\/b>aufgerufen und der Parameter Application <\/b>liefert einen Verweis auf die aufrufende Anwendung, in diesem Fall Access. Den Inhalt dieses Parameters schreiben wir direkt in die zuvor deklarierte Variable objApplication<\/b>, die mit dem Datentyp Access.Application <\/b>deklariert ist.<\/p>\n Außerdem implementiert die Klasse eine weitere Schnittstelle namens IRibbonExtensibility<\/b>. Diese wird benötigt, um vom COM-Add-In aus Ribbon-Anpassungen vorzunehmen. Hier müssen wir zusätzlich noch die Eigenschaft WithDispatchForwarding <\/b>voranstellen:<\/p>\n Schließlich benötigen wir noch eine Objektvariable, mit der wir die Ribbon-Erweiterung referenzieren können:<\/p>\n Das Grundgerüst der Klasse haben wir in Listing 1 abgebildet.<\/p>\n Listing 1: Grundstruktur des COM-Add-Ins<\/span><\/b><\/p>\n Die Funktion des COM-Add-Ins soll, wie eingangs erwähnt, über einen Befehl beziehungsweise ein Menü im Ribbon bereitgestellt werden. Damit dieses erscheint, müssen wir die Ribbon-Erweiterung, die das COM-Add-In bereitstellt, über die ebenfalls beim Start des Add-Ins aufgerufene Funktion GetCustomUI <\/b>zusammenstellen und als Rückgabewert dieser Funktion definieren.<\/p>\n In dieser stellen wir den kompletten XML-Ausdruck für die Ribbon-Erweiterung zusammen (siehe Listing 2).<\/p>\n Listing 2: Diese Funktion setzt das Ribbon zusammen.<\/span><\/b><\/p>\n Dies liefert eine XML-Definition wie die Folgende:<\/p>\n Das Kernstück ist das dynamicMenu<\/b>-Element, das mit der getContent<\/b>-Callback-Funktion beim Aufklappen dynamisch die Ereignisprozeduren für die aktuell markierten Elemente zusammenstellen soll.<\/p>\n Die dazu notwendige Funktion schauen wir uns weiter unten an.<\/p>\n Wichtig ist auch noch, dass wir für das Attribut onLoad <\/b>des Elements customUI <\/b>eine Callback-Funktion angeben, die beim ersten Laden des Ribbons ausgelöst wird.<\/p>\n Diese schreibt den mit dem Parameter ribbon <\/b>gelieferten Verweis auf das Ribbon in die weiter oben deklarierte Variable objRibbon<\/b>:<\/p>\n Warum benötigen wir dies Weil beim Öffnen des dynamicMenu<\/b>-Elements die Callbackfunktion zum Zusammenstellen des Menüs nur einmal aufgerufen wird – außer, wir machen diese „ungültig“. Und dazu müssen wir eine Methode der Objektvariablen für das IRibbonUI<\/b>-Objekt aufrufen.<\/p>\n Nun kommt der spannende Teil. Wie füllen wir das dynamicMenu<\/b>-Element beim Aufklappen des Menüs Die erste Anmerkung ist für Programmierer, die bereits einmal dynamicMenu<\/b>-Elemente unter Access verwendet haben.<\/p>\n Hier unter twinBASIC nutzen Sie eine etwas andere Syntax als unter VBA. Unter VBA lautet die erste Zeile der Callbackfunktion:<\/p>\n Unter twinBASIC verwenden wir die Deklaration wie unter VB6, die etwas anders aussieht:<\/p>\n <\/p>\n Danach deklariert die Funktion die notwendigen Variablen, von denen viele aus der Bibliothek Microsoft Visual Basic for Applications Extensibility 5.3<\/b> stammen. Das bedeutet: Wir werden direkt auf den Code im VBA-Editor zugreifen, um die Ereignisprozeduren der Elemente zu ermitteln.<\/p>\n Damit steigen wir nun in die Funktion GetContent <\/b>aus Listing 3 ein (im Download finden Sie eine bereits weiterentwickelte Version). Hier nutzen wir als Erstes eine Hilfsfunktion namens GetCurrentVBProject<\/b>, um das aktuelle VBA-Projekt zu referenzieren.<\/p>\n Listing 3: Diese Funktion setzt das dynamicMenu zusammen.<\/span><\/b><\/p>\n Das ist nötig, weil der VBA-Editor auch schon mal mehr als ein VBA-Projekt enthält – beispielsweise, wenn ein Access-Add-In geöffnet ist. Diese Funktion durchläuft alle VBA-Projekte, bis es eines findet, dessen Dateipfad mit dem der aktuellen Access-Anwendung übereinstimmt:<\/p>\n Dieses weisen wir der Variablen objVBProject <\/b>zu. Dann schreibt die Prozedur die erste Zeile des dynamicMenu<\/b>-Elements in die Variable strContent<\/b>:<\/p>\n Wir ermitteln sodann bei abgeschalteter Fehlerbehandlung mit Screen.ActiveControl <\/b>für das Access-Objekt aus objApplication <\/b>das aktuell aktive Formular und referenzieren dieses mit der Variablen frm<\/b>. Die Fehlerbehandlung schalten wir aus, weil ein Fehler ausgelöst würde, wenn aktuell kein Formular geöffnet ist. Ist ein Formular geöffnet, ist die Bedingung der folgenden If…Then<\/b>-Bedingung wahr.<\/p>\n Wir schalten erneut die Fehlerbehandlung aus und lesen das aktive Steuerelement aus, das in der Variablen ctl <\/b>landet. Das kein Steuerelement aktiv ist, kommt nur dann vor, wenn das Formular kein Steuerelement enthält, welches den Fokus erhalten kann. Ist ctl <\/b>danach nicht leer, werden die Anweisungen im If<\/b>-Zweig der folgenden If…Then<\/b>-Bedingung abgearbeitet.<\/p>\n Hier ermitteln wir den Namen des Formulars und tragen diesen in strVBComponent<\/b> ein. Dann prüfen wir mit der Eigenschaft HasModule<\/b>, ob das Formular frm <\/b>überhaupt ein Klassenmodul hat. Falls nicht, liegen logischerweise auch keine Ereignisprozeduren für das Formular vor.<\/p>\n Ist jedoch ein Klassenmodul vorhanden, referenzieren wir dieses über die Auflistung VBComponents <\/b>des VBProject<\/b>-Elements und dem aus dem Text Form_ <\/b>und dem Formularnamen bestehenden Index. Die Variable objCodeModule <\/b>füllen wir mit einem Verweis auf das CodeModule<\/b>-Objekt des VBComponent<\/b>-Elements.<\/p>\n Schließlich rufen wir eine Funktion namens GetEventsForm <\/b>auf, der wie den Formularnamen und die Objektvariable objCodeModule <\/b>übergeben, und die uns beispielsweise die folgende Zeile zurückliefert – hier im Falle einer einzigen Prozedur für das Ereignis Vor Aktualisierung <\/b>des Formulars:<\/p>\n Die ID soll immer eine Kombination aus dem Formularnamen und dem Namen der Ereignisprozedur sein. Als Bezeichnung (label<\/b>) verwenden wir den Namen der Ereignisprozedur. Für das Attribut tag <\/b>legen wir außerdem eine Zeichenkette fest, die aus dem Namen des Klassenmoduls und dem Namen der Ereignisprozedur besteht – getrennt durch das Pipe-Zeichen (|<\/b>). Aus dem tag<\/b>-Attribut lesen wir später die beiden Informationen aus.<\/p>\n Wie das Zusammenstellen gelingt, erklären wir weiter unten. Den Rückgabewert speichern wir in der Variablen strEventsForm<\/b>. Diesen hängen wir anschließend an den Inhalt von strContent<\/b> an, wo wir die einzelnen Zeilen des XML-Menüs sammeln.<\/p>\n Danach folgt eine wichtige Unterscheidung: Befindet sich das zu untersuchende Steuerelement eigentlich direkt in dem Formular aus frm <\/b>oder ist es vielleicht ein Steuerelement in einem Unterformular In welchem Objekt sich ein Steuerelement befindet, finden wir über die Eigenschaft Parent <\/b>heraus.<\/p>\n Meist handelt es sich hierbei um ein Formular. Es kann sich auch um ein Registersteuerelement handeln – aber diesen Fall decken wir für diese Lösung nicht ab. Mit dem Vergleich von ctl.Parent <\/b>mit frm <\/b>prüfen wir, ob sich das Steuerelement im aktuellen Hauptformular befindet. Falls nicht, untersuchen wir zusätzlich noch das Unterformular, in dem sich das Steuerelement befindet.<\/p>\n Dieses ermitteln wir mit ctl.Parent <\/b>und referenzieren es mit der Variablen sfm<\/b>. Auch hier prüfen wir wieder, ob das Formular ein Klassenmodul enthält. Falls ja, führen wir ähnliche Schritte durch wie für das Hauptformular – inklusive des Aufrufs der Funktion GetEventsForm<\/b>, dessen Ergebnis wir dann, getrennt von den vorherigen Einträgen, an die Variable strContent <\/b>anhängen.<\/p>\n Sollte weiter oben kein Steuerelement aktiviert gewesen sein, erscheint eine entsprechende Meldung.<\/p>\n Schließlich lesen wir noch die Ereignisprozeduren für das Steuerelement mit dem Fokus ein. Dazu prüfen wir nochmals das Vorhandensein eines Moduls, diesmal für das Formular, in dem sich das Steuerelement befindet. Dieses ermitteln wir mit ctl.Parent<\/b>. Auch hier gilt: Für Steuerelemente etwa auf Registerseiten funktioniert dies in der aktuellen Version nicht.<\/p>\n Diesmal rufen wir die Funktion GetEventsControl <\/b>auf, um die Menü-Einträge für das Steuerelement zu ermitteln. Diesem übergeben wir den Namen des Formulars aus strVBComponent<\/b>, das CodeModule<\/b>-Element und zusätzlich den Verweis auf das Steurerelement mit ctl<\/b>.<\/p>\n Nach dem Else<\/b>-Zweig der äußeren If…Then<\/b>-Bedingung, der eine Meldung anzeigt, wenn kein Formular den Fokus hat, hängt die Prozedur das schließende menu<\/b>-Element an strContent <\/b>an.<\/p>\n Schließlich folgt noch der Aufruf einer wichtigen Methode: Wir haben weiter oben einen Verweis auf die Ribbon-Definition in der Variablen objRibbon <\/b>gespeichert.<\/p>\n Diesen machen wir nun mit der Methode Invalidate <\/b>ungültig, damit die GetContent<\/b>-Callbackfunktion beim nächsten Aufklappen des Menüs erneut aufgerufen wird. Wenn wir das nicht tun, behält das Menü die zuvor ermittelten Einträge. Danach fehlt nur noch die Return<\/b>-Anweisung, mit der wir den Inhalt von strContent <\/b>an die aufrufende Instanz zurückliefern.<\/p>\n Hinweis: Von VBA kennen Sie es so, dass der Rückgabewert einer Variablen mit dem Namen der Funktion zugewiesen wird. twinBASIC bietet einige Unterschiede zu VBA, zum Beispiel die Rückgabe mit der etwas besser lesbaren Anweisung Return<\/b>.<\/p>\n Die Funktion GetEventsForm<\/b>, die Sie in Listing 4 finden, übernimmt die Kleinarbeit. Sie durchläuft alle Zeilen des mit objCodeModule <\/b>übergebenen Moduls in einer For…Next<\/b>-Schleife. Dabei starten wir bei der Zeile, die mit CountOfDeclarationLines <\/b>geliefert wird, also direkt hinter den Deklarationen im Modulkopf. Die letzte Zeile ist die mit CountOfLines <\/b>ermittelte letzte Zeile des Moduls.<\/p>\n Listing 4: Diese Funktion liefert den XML-Code zur Anzeige der Ereignisprozeduren eines Formulars zurück.<\/span><\/b><\/p>\n In dieser Schleife lesen wir den Namen der Prozedur ein, die sich in dieser Zeile befindet. Dazu verwenden wir die ProcOfLine<\/b>-Funktion, welche die zu untersuchende Zeile entgegennimmt und mit dem zweiten Parameter lngProc-Kind <\/b>den Typ der Prozedur zurückliefert. Die gefundene Prozedur speichern wir in der Variablen strCurrentSub<\/b>.<\/p>\n In der folgenden If…Then<\/b>-Schleife vergleichen wir den Namen der Prozedur aus strCurrentSub <\/b>mit dem Wert einer weiteren Variablen namens strPreviousSub<\/b>. Diese ist beim ersten Durchlauf noch leer, daher ist die Bedingung wahr. In den folgenden Durchläufen wird jeweils strCurrentSub <\/b>in strPreviousSub <\/b>geschrieben und die nächste Zeile eingelesen – bis strCurrentSub <\/b>den Namen der folgenden Prozedur erhält. Erst dann wird der Inhalt der If…Then<\/b>-Bedingung erneut ausgeführt.<\/p>\n Innerhalb der If…Then<\/b>-Bedingung geschieht Folgendes: Die Prozedur prüft, ob der Name der Prozedur mit Form_ <\/b>beginnt. Ist das der Fall, handelt es sich um eine Ereignisprozedur des Formulars. Dann hängen wir an die Variable strEventsForm <\/b>ein Element wie das weiter oben bereits vorgestellte an.<\/p>\n Dabei werden die einzelnen Bestandteile aus den Variablen strVBComponent <\/b>und strCurrentSub <\/b>ermittelt. Nachdem auf diese Weise alle Prozeduren des Moduls durchlaufen wurden, gibt die Funktion das Ergebnis aus strEventsControl <\/b>mit der Return<\/b>-Anweisung zurück.<\/p>\n Die Definition eines durch die Funktion GetEventsControl <\/b>zusammengesetzten button<\/b>-Elements für das dynamicMenu <\/b>sieht beispielsweise wie folgt aus:<\/p>\n Das button<\/b>-Element enthält für das Attribut id <\/b>den Namen des Formulars und den Namen der Ereignisprozedur, getrennt durch einen Unterstrich. Als Label verwenden wir den Namen der Ereignisprozedur.<\/p>\n Für das tag<\/b>-Attribut legen wir den Namen des Klassenmoduls und den Namen der Ereignisprozedur fest, wiederum getrennt durch das Pipe-Zeichen.<\/p>\n Die Funktion zum Zusammenstellen des button<\/b>-Elements finden Sie in Listing 5. Sie arbeitet fast genauso wie die Funktion Get-EventsForm<\/b>, allerdings sucht sie nach Ereignisprozeduren, die mit dem Namen des Steuerelements beginnen.<\/p>\n Listing 5: Diese Funktion liefert den XML-Code zur Anzeige der Ereignisprozeduren eines Steuerelements zurück.<\/span><\/b><\/p>\n Der einzige Unterschied ist, dass sie eine Variable namens strControlImage <\/b>verwendet, die sie mit der Funktion GetControlImage <\/b>füllt. Diese erhält mit ctl <\/b>einen Verweis auf das Steuerelement als Parameter und liefert den Namen des anzuzeigenden Icons als Ergebnis zurück.<\/p>\n Den Inhalt dieser Variablen arbeitet die Funktion Get-EventsControl <\/b>dann schließlich als Wert des Attributs imageMso <\/b>ein.<\/p>\n Die Funktion GetEventsControl <\/b>finden Sie in Listing 6. Sie prüft in einer Select Case<\/b>-Bedingung mit ctl.ControlType <\/b>den Typ des Steuerelements. Wir haben hier die Einträge für die gängigsten Steuerelementtypen angegeben, alle anderen werden im Zweig ![\"Setzen](\"..\/fileadmin\/_temp_\/2021_04\/pic_1317_003.png\")
<\/p>\nDebuggen, die leichte Version<\/h2>\n
![\"Anzeige](\"..\/fileadmin\/_temp_\/2021_04\/pic_1317_004.png\")
<\/p>\n![\"Anzeige](\"..\/fileadmin\/_temp_\/2021_04\/pic_1317_005.png\")
<\/p>\nProgrammieren des COM-Add-Ins<\/h2>\n
Projekt öffnen<\/h2>\n
Projektelemente umbenennen<\/h2>\n
![\"Anpassen](\"..\/fileadmin\/_temp_\/2021_04\/pic_1317_006.png\")
<\/p>\nKlassenname ändern<\/h2>\n
Class<\/span> EreignisprozedurAnzeigen\r\n Implements IDTExtensibility2\r\n ...<\/pre>\nVerweise auf Bibliotheken anlegen<\/h2>\n
\n
![\"Hinzufügen](\"..\/fileadmin\/_temp_\/2021_04\/pic_1317_001.png\")
<\/p>\nCOM-Add-In für Access vorbereiten<\/h2>\n
[WithDispatchForwarding]\r\nImplements IRibbonExtensibility<\/pre>\n
Public <\/span>objRibbon As <\/span>IRibbonUI<\/pre>\nClass<\/span> EreignisprozedurAnzeigen\r\n Implements IDTExtensibility2\r\n [WithDispatchForwarding]\r\n Implements IRibbonExtensibility\r\n \r\n Private <\/span>objApplication As <\/span>Access.Application\r\n \r\n Sub OnConnection(ByVal Application As Object<\/span>, ByVal ConnectMode As <\/span>ext_ConnectMode, _\r\n ByVal AddInInst As Object<\/span>, ByRef custom As Variant<\/span>()) Implements IDTExtensibility2.OnConnection\r\n Set<\/span> objApplication = Application\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 End Sub\r\n \r\n Sub OnAddInsUpdate(ByRef custom As Variant<\/span>()) Implements IDTExtensibility2.OnAddInsUpdate\r\n End Sub\r\n \r\n Sub OnStartupComplete(ByRef custom As Variant<\/span>()) Implements IDTExtensibility2.OnStartupComplete\r\n End Sub\r\n \r\n Sub OnBeginShutdown(ByRef custom As Variant<\/span>()) Implements IDTExtensibility2.OnBeginShutdown\r\n End Sub\r\n ...\r\nEnd Class<\/span><\/pre>\nAufruf über das Ribbon <\/h2>\n
Private Function <\/span>GetCustomUI(ByVal RibbonID As String<\/span>) As String<\/span> _\r\n Implements IRibbonExtensibility.GetCustomUI\r\n Dim <\/span>strXML As String<\/span>\r\n strXML &= \"<customUI xmlns=\"\"http:\/\/schemas.microsoft.com\/office\/2006\/01\/customui\"\" onLoad=\"\"OnLoad\"\">\" & vbCrLf<\/span>\r\n strXML &= \" <ribbon startFromScratch=\"\"false\"\">\" & vbCrLf<\/span>\r\n strXML &= \" <tabs>\" & vbCrLf<\/span>\r\n strXML &= \" <tab id=\"\"tabTest\"\" label=\"\"amvAccessTools\"\">\" & vbCrLf<\/span>\r\n strXML &= \" <group id=\"\"grpSteuerelemente\"\" label=\"\"Steuerelemente\"\">\" & vbCrLf<\/span>\r\n strXML &= \" <dynamicMenu id=\"\"dmnEvents\"\" label=\"\"Ereignisprozeduren anzeigen\"\"\" _\r\n & \" getContent=\"\"GetContent\"\" imageMso=\"\"CreateModule\"\" size=\"\"large\"\"\/>\" & vbCrLf<\/span>\r\n strXML &= \" <\/group>\" & vbCrLf<\/span>\r\n strXML &= \" <\/tab>\" & vbCrLf<\/span>\r\n strXML &= \" <\/tabs>\" & vbCrLf<\/span>\r\n strXML &= \" <\/ribbon>\" & vbCrLf<\/span>\r\n strXML &= \"<\/customUI>\" & vbCrLf<\/span>\r\n Return strXML\r\nEnd Function<\/span><\/pre>\n<customUI xmlns=\"http:\/\/schemas.microsoft.com\/ office\/2006\/01\/customui\" onLoad=\"OnLoad\">\r\n <ribbon startFromScratch=\"false\">\r\n <tabs>\r\n <tab id=\"tabTest\" label=\"amvAccessTools\">\r\n <group id=\"grpSteuerelemente\" label=\"Steuerelemente\">\r\n <dynamicMenu id=\"dmnEvents\" label=\"Ereignisprozeduren anzeigen\" getContent=\"GetContent\" imageMso=\"CreateModule\" size=\"large\"\/>\r\n <\/group>\r\n <\/tab>\r\n <\/tabs>\r\n <\/ribbon>\r\n<\/customUI><\/pre>\n
Ribbon per Variable referenzieren<\/h2>\n
Sub <\/span>OnLoad(ribbon As <\/span>IRibbonUI)\r\n Set<\/span> objRibbon = ribbon\r\nEnd Sub<\/span><\/pre>\ndynamicMenu beim Aufklappen des Menüs füllen<\/h2>\n
Sub <\/span>GetContent(control As <\/span>IRibbonControl, ByRef XMLString)<\/pre>\nFunction <\/span>GetContent(control As <\/span>IRibbonControl) As String<\/span><\/pre>\nVBA-Projekt per Hilfsfunktion holen<\/h2>\n
Function <\/span>GetContent(control As <\/span>IRibbonControl) As String<\/span>\r\n Dim <\/span>objVBProject As <\/span>VBProject, objVBComponent As <\/span>VBComponent, objCodeModule As <\/span>CodeModule\r\n Dim <\/span>frm As <\/span>Form, sfm As <\/span>Form, ctl As <\/span>Control\r\n Dim <\/span>strVBComponent As String<\/span>, strContent As String<\/span>\r\n Dim <\/span>strEventsForm As String<\/span>, strEventsSubform As String<\/span>, strEventsControl As String<\/span>\r\n Set<\/span> objVBProject = GetCurrentVBProject\r\n strContent = \"<menu xmlns=\"\"http:\/\/schemas.microsoft.com\/office\/2006\/01\/customui\"\">\" & vbCrLf<\/span>\r\n On Error Resume Next<\/span>\r\n Set<\/span> frm = objApplication.Screen.ActiveForm\r\n On Error Goto 0\r\n If <\/span>Not<\/span> frm Is Nothing Then<\/span>\r\n On Error Resume Next<\/span>\r\n Set<\/span> ctl = objApplication.Screen.ActiveControl\r\n On Error Goto 0\r\n If <\/span>Not<\/span> ctl Is Nothing Then<\/span>\r\n strVBComponent = frm.Name\r\n If <\/span>frm.HasModule Then<\/span>\r\n Set<\/span> objVBComponent = objVBProject.VBComponents(\"Form_\" & strVBComponent)\r\n Set<\/span> objCodeModule = objVBComponent.CodeModule\r\n strEventsForm = GetEventsForm(strVBComponent, objCodeModule)\r\n strContent = strContent & strEventsForm\r\n End If<\/span>\r\n If <\/span>Not<\/span> ctl.Parent Is frm Then<\/span>\r\n Set<\/span> sfm = ctl.Parent\r\n If <\/span>sfm.HasModule Then<\/span> \r\n strVBComponent = ctl.Parent.Name\r\n Set<\/span> objVBComponent = objVBProject.VBComponents(\"Form_\" & strVBComponent)\r\n Set<\/span> objCodeModule = objVBComponent.CodeModule\r\n strEventsSubForm = GetEventsForm(strVBComponent, objCodeModule)\r\n strContent = strContent & \"<menuSeparator id=\"\"sep2\"\"\/>\"\r\n strContent = strContent & strEventsSubform\r\n End If<\/span>\r\n End If<\/span>\r\n Else<\/span>\r\n MsgBox<\/span> \"Kein Steuerelement aktiviert.\", vbExclamation + vbOKOnly, \"Fehlende Selektion\" \r\n End If<\/span>\r\n If <\/span>ctl.Parent.HasModule Then<\/span>\r\n strContent = strContent & \"<menuSeparator id=\"\"sep3\"\"\/>\" & vbCrLf<\/span>\r\n strEventsControl = GetEventsControl(strVBComponent, objCodeModule, ctl)\r\n strContent = strContent & strEventsControl\r\n End If<\/span>\r\n Else<\/span>\r\n MsgBox<\/span> \"Kein Formular aktiviert.\", vbExclamation + vbokonly, \"Fehlende Selektion\"\r\n End If<\/span>\r\n strContent = strContent & \" <\/menu>\"\r\n objRibbon.Invalidate\r\n Return strContent\r\nEnd Function<\/span><\/pre>\nPublic Function <\/span>GetCurrentVBProject() As <\/span>VBProject\r\n Dim <\/span>objVBProject As <\/span>VBProject\r\n For Each objVBProject In objApplication.VBE.VBProjects\r\n If <\/span>(objVBProject.FileName = objApplication.CurrentDb.Name) Then<\/span>\r\n Set<\/span> GetCurrentVBProject = objVBProject\r\n Exit Function<\/span>\r\n End If<\/span>\r\n Next<\/span> objVBProject\r\nEnd Function<\/span><\/pre>\nMenü zusammenstellen<\/h2>\n
<menu xmlns=\"http:\/\/schemas.microsoft.com\/office\/ 2006\/01\/customui\"><\/pre>\n
<button id=\"frmArtikel_Form_BeforeUpdate\" \r\n imageMso=\"ChooseForm\" \r\n label=\"Form_BeforeUpdate\" \r\n onAction=\"OnAction\" \r\n tag=\"Form_frmArtikel|Form_BeforeUpdate\"\/><\/pre>\n
Auf Unterformular prüfen<\/h2>\n
Steuerelement-Ereignisprozeduren einlesen<\/h2>\n
Ribbon „ungültig“ machen<\/h2>\n
Ereignisprozeduren für Formular einlesen<\/h2>\n
Function <\/span>GetEventsForm(strVBComponent As String<\/span>, objCodeModule As <\/span>CodeModule) As String<\/span>\r\n Dim <\/span>strEventsForm As String<\/span>\r\n Dim <\/span>strCurrentSub As String<\/span>\r\n Dim <\/span>strPreviousSub As String<\/span>\r\n Dim <\/span>lngProcKind As <\/span>vbext_ProcKind\r\n Dim <\/span>l As Long<\/span>\r\n For l = objCodeModule.CountOfDeclarationLines + 1 To objCodeModule.CountOfLines\r\n strCurrentSub = objCodeModule.ProcOfLine(l, lngProcKind)\r\n If <\/span>Not<\/span> strCurrentSub = strPreviousSub Then<\/span>\r\n If <\/span>Left<\/span>(strCurrentSub, 5) = \"Form_\" Then<\/span>\r\n strEventsForm = strEventsForm & \"<button id=\"\"\" & strVBComponent & \"_\" & strCurrentSub _\r\n & \"\"\" imageMso=\"\"ChooseForm\"\" label=\"\"\" & strCurrentSub & \"\"\" onAction=\"\"OnAction\"\"\" _\r\n & \" tag=\"\"Form_\" & strVBComponent & \"|\" & strCurrentSub & \"\"\"\/>\" & vbCrLf<\/span>\r\n End If<\/span>\r\n End If<\/span>\r\n strPreviousSub = strCurrentSub\r\n Next<\/span> l\r\n Return strEventsForm\r\nEnd Function<\/span><\/pre>\nEreignisprozeduren für Steuerelemente einlesen<\/h2>\n
<button id=\"frmArtikel_cmdPDFUndBeispieleUploaden_Click\" \r\n imageMso=\"ActiveXButton\" \r\n label=\"cmdPDFUndBeispieleUploaden_Click\" \r\n onAction=\"OnAction\" \r\n tag=\"Form_frmArtikel|cmdPDFUndBeispieleUploaden_Click\"\/><\/pre>\n
Function <\/span>GetEventsControl(strVBComponent As String<\/span>, objCodeModule As <\/span>CodeModule, ctl As <\/span>Control) As String<\/span>\r\n Dim <\/span>strEventsControl As String<\/span>\r\n Dim <\/span>strCurrentSub As String<\/span>\r\n Dim <\/span>strPreviousSub As String<\/span>\r\n Dim <\/span>lngProcKind As <\/span>vbext_ProcKind\r\n Dim <\/span>strControlImage As String<\/span>\r\n Dim <\/span>l As Long<\/span>\r\n For l = objCodeModule.CountOfDeclarationLines + 1 To objCodeModule.CountOfLines\r\n strCurrentSub = objCodeModule.ProcOfLine(l, lngProcKind)\r\n strControlImage = GetControlImage(ctl)\r\n If <\/span>Not<\/span> strCurrentSub = strPreviousSub Then<\/span>\r\n If <\/span>Left<\/span>(strCurrentSub, Len<\/span>(ctl.Name) + 1) = ctl.Name & \"_\" Then<\/span>\r\n strEventsControl = strEventsControl & \"<button id=\"\"\" & strVBComponent & \"_\" & strCurrentSub _\r\n & \"\"\" imageMso=\"\"\" & strControlImage & \"\"\" label=\"\"\" & strCurrentSub _\r\n & \"\"\" onAction=\"\"OnAction\"\" tag=\"\"Form_\" & strVBComponent & \"|\" & strCurrentSub & \"\"\"\/>\" & vbCrLf<\/span>\r\n End If<\/span>\r\n End If<\/span>\r\n strPreviousSub = strCurrentSub\r\n Next<\/span> l\r\n Return strEventsControl\r\nEnd Function<\/span><\/pre>\n