<\/p>\n
Neben COM-DLLs können Sie mit twinBASIC auch COM-Add-Ins programmieren, deren Funktionen dann in der Benutzeroberfläche von Access angezeigt und genutzt werden können. Die Möglichkeiten sind unbegrenzt – Sie können damit beispielsweise Ribbon-Einträge hinzufügen, die dauerhaft und unabhängig von der jeweils geöffneten Datenbank verfügbar sind und damit selbst programmierte Funktionen aufrufen. Welche Funktionen sinnvoll sind und sich hier umsetzen lassen, schauen wir uns in weiteren Beiträgen an. Dieser Beitrag beleuchtet zunächst einmal die technischen Grundlagen für die Erstellung von COM-Add-Ins für die Access-Benutzeroberfläche.<\/b><\/p>\nCOM-Add-Ins und Access-Add-Ins<\/h2>\n
Bevor wir in die Materie einsteigen, wollen wir den Unterschied zwischen COM-Add-Ins und Access-Add-Ins klären. Access-Add-Ins sind Access-Datenbanken, die eine spezielle Dateiendung enthalten und eine Tabelle namens USysRegInfo <\/b>mit Einträgen, welche Informationen über das Add-In zum Eintragen in die Registry enthalten.<\/p>\n
Diese rufen Sie schließlich über den Ribbon-Eintrag Datenbanktools|Add-Ins|Add-Ins <\/b>auf. Bild 1 zeigt einige Add-Ins in der Access-Installation des Autors dieses Beitrags. Ein Klick auf einen dieser Einträge startet diesen und zeigt beispielsweise ein Formular mit den enthaltenen Funktionen an. Es gibt noch weitere Möglichkeiten, Access-Add-Ins zu platzieren – zum Beispiel als Steuerelement-Assistent oder Formular-Assistent.<\/p>\n
![\"Access-Add-Ins\"](\"..\/fileadmin\/_temp_\/2021_03\/pic_1306_001.png\")
<\/p>\n
Bild 1: Access-Add-Ins<\/span><\/b><\/p>\n Der wichtigste Unterschied zwischen Access-Add-Ins und den hier vorgestellten COM-Add-Ins für Access ist, dass Sie für COM-Add-Ins keine speziellen Orte vorfinden, an denen Sie deren Aufruf platzieren können. Stattdessen fügen Sie einfach im gewünschten Ribbon einen Eintrag hinzu oder auch ein eigenes Ribbon, über das Sie das COM-Add-In starten können. Der zweite wichtige Unterschied ist, dass Sie Access-Add-Ins komplett mit Access erstellen. Sie brauchen dann nur die Dateiendung von .accdb <\/b>auf .accda<\/b> zu ändern und die bereits erwähnte Tabelle namens USysRegInfo <\/b>mit Informationen über die Art des Access-Add-Ins, den Namen et cetera sowie die auszuführende Funktion hinzuzufügen.<\/p>\n Ein COM-Add-In hingegen können Sie nicht einfach mit Access erstellen, sondern Sie benötigen dazu eine externe Entwicklungsumgebung. Früher hat man das mit Visual Studio 6 erledigt. Auch der Nachfolger Visual Studio .NET hat im Laufe der Zeit verschiedene Tools zum Erstellen von Office-Add-Ins angeboten.<\/p>\n Für die Erstellung von Access-Add-Ins musste man jedoch unter Visual Studio .NET immer improvisieren: Vorlagen gab es nämlich nur für die populäreren Office-Anwendungen wie Word, Outlook oder Excel.<\/p>\n Der Nachteil bei der COM-Add-In-Entwicklung unter Visual Studio 6 zeigt sich aktuell zunehmend darin, dass immer mehr Installationen von Office beziehungsweise Access die 64-Bit-Version verwenden. Und Visual Studio 6 erstellt nur Projekte in der 32-Bit-Version. Insofern sind mit twinBASIC<\/b> erstellte COM-Add-Ins auch zukunftssicherer.<\/p>\n Im April 2021 hat jedoch Wayne Philips, der bereits mit dem Fehler- und Debugging-Tool vbWatchdog von sich hören machte, eine erste Version seiner Entwicklungsumgebung für VB- und VBA-kompatible Projekte veröffentlicht. Diese basiert auf Visual Studio Code und nutzt eine eigene Erweiterung für das Programmieren von VB- und VBA-Projekten.<\/p>\n In Kürze soll man damit auch Anwendungen mit Benutzeroberfläche damit programmieren können, derzeit ist das aber noch nicht möglich. Für uns spielt das keine Rolle – wir schauen uns erst einmal die grundlegenden Möglichkeiten der Erstellung von COM-Add-Ins für die Access-Benutzeroberfläche an.<\/p>\n Die Grundlagen zum Einrichten von Visual Studio Code und der für die VB-Programmierung benötigten Erweiterung haben wir bereits im Beitrag twinBASIC – VB\/VBA mit moderner Umgebung <\/b>(www.access-im-unternehmen.de\/1303<\/b>) beschrieben. Im vorliegenden Beitrag bauen wir auf einem einfachen Template für ein Access-COM-Add-In auf und erläutern die einzelnen Bestandteile. Anschließend fügen wir dem COM-Add-In einige Beispielfunktionen hinzu.<\/p>\n Wir starten mit einem Beispielprojekt, das Sie per Doppelklick auf die Datei myAccessAddIn.code-workspace <\/b>starten. Dies öffnet das Projekt im twinBASIC-Editor beziehungsweise in Visual Studio Code wie in Bild 2.<\/p>\n Bild 2: Aufbau eines Projekts für die Erstellung eines COM-Add-Ins<\/span><\/b><\/p>\n Die hier sichtbaren Prozeduren sind die Implementierung einer Schnittstelle namens IDExtensibility2<\/b>, die bereits seit VB6 zum Implementieren der Funktionen für COM-Add-Ins für die verschiedenen Office-Anwendungen und auch für den VBA-Editor verwendet wird (siehe Listing 1).<\/p>\n Listing 1: Implementierung der Schnittstelle für COM-Add-Ins<\/span><\/b><\/p>\n Um diese in der Klasse unseres twinBASIC-Projekts zu implementieren, fügen wir dem Modul HelloWorld.twin <\/b>die folgende Zeile hinzu:<\/p>\n Diese Schnittstelle ist in der Bibliothek Microsoft Add-In Designer <\/b>definiert, die genau wie die Implementierung der Schnittstelle bereits im Beispielprojekt enthalten ist. Die Verweise auf Bibliotheken finden Sie übrigens im Bereich Settings <\/b>unter COM Type Library \/ ActiveX References <\/b>(siehe Bild 3).<\/p>\n Bild 3: Notwendige Verweise für ein Access-Add-In<\/span><\/b><\/p>\n Hier haben wir auch gleich noch die Bibliothek Microsoft Office 16.0 Object Library <\/b>hinzugefügt, denn wir wollen später auch noch ein Ribbon zum Aufrufen der Befehle des COM-Add-Ins zum Projekt hinzufügen. Diesen Verweis finden Sie schnell in der Liste, wenn Sie im Suchen-Feld Teile des Verweisnamens eingeben, beispielsweise Office<\/b>.<\/p>\n Diese Schnittstelle enthält einige Ereignisprozeduren, die zu verschiedenen Gelegenheiten ausgelöst werden. Das Besondere an einer Schnittstelle ist, dass Sie alle dafür definierten Ereignisse implementieren müssen – auch wenn diese gar keine Befehle enthalten und somit nichts tun.<\/p>\n Die wichtigste Ereignisprozedur für diese Implementierung für uns ist in der Regel die Methode OnConnection<\/b>. Diese wird aufgerufen, wenn Access startet und nachdem es im entsprechenden Registry-Zweig nachgesehen hat, ob irgendwelche COM-Add-Ins geladen werden müssen – dazu später mehr.<\/p>\n Diese Ereignisprozedur stellt zwei wichtige Parameter zur Verfügung:<\/p>\n Mit dem Verweis auf das Application<\/b>-Objekt der Anwendung können Sie dann vom Code des COM-Add-Ins aus auf die Anwendung selbst zugreifen. Um diesen Verweis während der Verwendung des COM-Add-Ins ständig im Zugriff zu haben, speichern wir es in einer Variablen, die wir wir folgt deklarieren:<\/p>\n Sie ahnen es bereits: Wenn wir Elemente der Access-Bibliothek verwenden, benötigen wir auch noch einen Verweis auf die Bibliothek Microsoft Access 16.0 Object Library<\/b>. Diesen fügen Sie noch über den oben bereits erwähnten Bereich COM Type Library \/ ActiveX References <\/b>hinzu.<\/p>\n Wichtig: Damit die enthaltenen Elemente auch im Code zur Verfügung stehen, müssen Sie die geänderten Einstellungen einmal speichern.<\/p>\n Das gelingt am einfachsten, wenn Sie noch während der Anzeige des Einstellungen-Bereichs die Tastenkombination Strg + S <\/b>betätigen. Den mit dem Parameter AddInInst <\/b>gelieferten Verweis speichern wir in der folgenden Variablen:<\/p>\n Damit die beiden Parameter auch in diesen Variablen landen, fügen wir neben einer Meldungsanweisung die folgenden beiden Zeilen in die Ereignisprozedur OnConnection <\/b>ein:<\/p>\n <\/p>\n Mit der Meldung prüfen wir, ob das COM-Add-In überhaupt geladen wird.<\/p>\n Wenn Sie die Build<\/b>-Schaltfläche in der twinBASIC-Erweiterung von Visual Studio Code verwenden, erstellt dies nicht nur die DLL-Datei mit dem COM-Add-In, sondern es werden bereits die grundlegenden Registrierungseinträge vorgenommen. Das sind die Einträge, die auch für die Registrierung einer einfachen COM-DLL notwendig sind. <\/p>\n Ob das COM-Add-In erfolgreich erstellt wurde, entnehmen Sie dem Bereich Debugging-Console <\/b>von Visual Studio Code (siehe Bild 4).<\/p>\n Bild 4: Ausgabe beim erfolgreichen Erstellen des COM-Add-Ins<\/span><\/b><\/p>\n Für ein COM-Add-In sind aber noch ein paar weitere Einträge notwendig, die Sie aktuell noch manuell hinzufügen müssen. Wobei manuell bedeutet, dass Sie eine Registrierungsdatei aufrufen müssen, die dann die einzelnen Schritte für Sie erledigt.<\/p>\n Dazu legen Sie eine Textdatei mit der Dateiendnung .reg<\/b> an, der Sie den Inhalt aus Listing 2 hinzufügen. Nachdem Sie diese Datei erstellt und gespeichert haben, rufen Sie diese per Doppelklick auf.<\/p>\n Listing 2: Registrierungseintrag für das COM-Add-In<\/span><\/b><\/p>\n Anschließend können Sie in der Registrierung von Windows prüfen, ob alle benötigten Einträge vorgenommen wurden. Den Registrierungseditor öffnen Sie durch Eingabe von regedit <\/b>in das Suchen-Fenster von Windows und das anschließende Aufrufen der Anwendung Registrierungs-Editor<\/b>.<\/p>\n Hier navigieren Sie zum Zweig HKEY_CURRENT_USER\\SOFTWARE\\Microsoft\\Office\\Access\\Addins\\MyAccess-AddIn<\/b>, der wie in Bild 5 aussehen sollte.<\/p>\n Bild 5: Einträge für das COM-Add-In in die Windows-Registrierung<\/span><\/b><\/p>\n Damit können wir das COM-Add-In erstmalig testen. Hier noch einmal die Voraussetzungen:<\/p>\n Ob das COM-Add-In erstellt wurde, können Sie im Ordner Build<\/b> des Projektordners prüfen – hier sollten Sie eine neu erstellte .dll<\/b>-Datei vorfinden.<\/p>\n Wenn Sie danach Access starten, sollte eine MsgBox erscheinen, die den Text myAccessAddin.OnConnection <\/b>anzeigt. Damit haben wir die Basis für ein Access-Add-In gelegt.<\/p>\n Wenn Sie die Funktionen des COM-Add-Ins aufrufen wollen, gibt es unter Access keine andere Möglichkeit als einen Ribbon-Befehl.<\/p>\n Diesen müssen wir allerdings erst einmal hinzufügen. Dazu gibt es eine weitere Schnittstelle, die wir normalerweise wie folgt zur Klasse unseres Projekts hinzufügen:<\/p>\n Es gibt jedoch eine kleine Erweiterung, die wir im Falle der Erstellung des COM-Add-Ins mit twinBASIC hinzufügen müssen. Dabei handelt es sich um die Eigenschaft WithDispatchForwarding<\/b>, die Sie der Implements<\/b>-Anweisung voranstellen:<\/p>\n Der Grund ist, dass sonst kein Aufruf der Callback-Funktionen in der COM-DLL möglich ist.<\/p>\n Die Schnittstelle IRibbonExtensibility <\/b>ist Teil der oben bereits per Verweis eingebundenen Bibliothek Microsoft Office 16.0 Object Library<\/b>. Haben Sie diesen also noch nicht hinzugefügt, ist jetzt ein geeigneter Zeitpunkt dafür gekommen (Speichern der Einstellungen anschließend nicht vergessen).<\/p>\n Diese Schnittstelle erfordert nur die Implementierung einer einzigen Ereignisprozedur, nämlich GetCustomUI<\/b>.<\/p>\n Diese hat einen String<\/b>-Parameter namens Ribbon-ID<\/b>, der die anzuwendende Ribbon-Definition erwartet. Listing 3 zeigt, wie wir die Ribbon-Definition in dieser Ereignisprozedur zusammenstellen.<\/p>\n Listing 3: Zusammenstellen der Ribbon-Definition<\/span><\/b><\/p>\n Das Ergebnis nach dem erneuten Erstellen des COM-Add-Ins und dem Öffnen von Access sehen Sie in Bild 6.<\/p>\n Bild 6: Ribbon-Befehle des COM-Add-Ins<\/span><\/b><\/p>\n Für die in der Ribbon-Definition festgelegten Prozeduren für die onAction<\/b>-Attribute hinterlegen wir nun noch Callbackroutinen in der Klasse.<\/p>\n Fürs Erste reicht eine allgemeine Callback-Funktion, die einfach nur den Namen der aufrufenden Ribbon-Schaltfläche ausgibt:<\/p>\n Erstellen Sie das COM-Add-In nun neu und starten danach Access, können Sie mit einem Klick auf eine der Ribbon-Schaltfläche die gewünschte Meldung anzeigen (siehe Bild 7).<\/p>\n Bild 7: Durch das Ribbon aufgerufene Meldung<\/span><\/b><\/p>\n Wenn Sie das COM-Add-In erstellt und registriert haben, kann es beim Öffnen von Access zu Laufzeitfehlern im COM-Add-In kommen. Tritt ein solcher Fehler auf, wird das COM-Add-In in der Regel deaktiviert – manchmal mit und manchmal ohne entsprechende Meldung.<\/p>\n Diese Deaktivierung wirkt sich so aus, dass der Wert der Eigenschaft LoadBehaviour <\/b>in der Registry auf den Wert 2 <\/b>statt 3 <\/b>eingestellt wird (siehe Bild 8).<\/p>\n Bild 8: Zurückgesetztes Ladeverhalten<\/span><\/b><\/p>\n Um dies zu ändern, haben Sie zunächst die Möglichkeit, den Wert gleich in der Registry wieder auf 3 <\/b>einzustellen. Das COM-Add-In wird dann beim nächsten Start von Access wieder geladen. Allerdings sollten Sie dann auch in Visual Studio Code den Fehler beheben und das COM-Add-In neu kompilieren.<\/p>\n Die zweite Möglichkeit ist der erneute Aufruf der Registrierungsdatei RegisterAddin32.reg<\/b>. Dies überschreibt einfach den vorhandenen Eintrag.<\/p>\n Sie können sich allerdings auch in Access selbst einen Überblick darüber verschaffen, welche COM-Add-Ins überhaupt gerade geladen werden und welche zwar registriert sind, aber nicht geladen werden. Dazu öffnen Sie den Optionen<\/b>-Dialog von Access und wechseln dort zum Bereich Add-Ins<\/b>.<\/p>\n Hier wählen Sie unter Verwalten: <\/b>den Eintrag COM-Add-Ins <\/b>aus und zeigen mit einem Klick auf Los… <\/b>den Dialog aus Bild 9 an. Wenn vor dem Namen des betroffenen COM-Add-Ins kein Haken gesetzt ist, dann wurde das COM-Add-In deaktiviert. Sie können es hier durch Setzen des Hakens wieder aktivieren.<\/p>\n Bild 9: Das COM-Add-In ist deaktiviert.<\/span><\/b><\/p>\n Hier gilt wie für alle anderen professionellen Anwendungen: Mit einer konsistenten Fehlerbehandlung können Sie solche Nebenwirkungen wie die Deaktivierung von COM-Add-Ins leicht verhindern.<\/p>\n Wenn Sie das COM-Add-In neu erstellen, nachdem Sie einen Fehler korrigiert oder andere Änderungen vorgenommen haben, wird Ihnen voraussichtlich der folgende Fehler unterlaufen: Sie erstellen das COM-Add-In neu, während noch eine Access-Instanz geöffnet ist, die auf das Add-In zugreift. Zu diesem Zeitpunkt ist die DLL-Datei des COM-Add-Ins jedoch noch schreibgeschützt und kann nicht gelöscht und erneuert werden. Wenn Sie nicht aufmerksam sind, entgeht Ihnen dann auch noch die Meldung aus dem Debugging-Bereich aus Bild 10.<\/p>\n Bild 10: Fehler beim Versuch, das COM-Add-In zu erstellen<\/span><\/b><\/p>\n An dieser Stelle heißt es also einfach: Alle Access-Instanzen schließen, die gegebenenfalls noch auf das COM-Add-In zugreifen könnten, und das Erstellen des COM-Add-Ins erneut starten. Je nachdem, ob Sie das COM-Add-In wegen eines Fehlers aktualisiert haben, sollten Sie auch noch die Registrierungseinträge aktualisieren.<\/p>\n Über den Parameter Application <\/b>liefert die Ereignisprozedur OnConnection <\/b>einen Verweis auf die aufrufende Anwendung, über den Parameter AddinInst <\/b>können Sie auf das COM-Add-In selbst zugreifen.<\/p>\n Diese beiden Parameterwerte speicherten wir ja bereits in entsprechenden Variablen, nämlich in _Access <\/b>und _AddIn<\/b>.<\/p>\n Wenn Sie nun vom COM-Add-In auf die Access-Instanz zugreifen wollen, ist die Variable _Access <\/b>die erste Anlaufstelle. Diese liefert einen Objektverweis auf die Access-Instanz zurück, die das COM-Add-In geladen hat. Diese können Sie später nutzen, um etwa beim Betätigen eines Ribbon-Befehls die gewünschten Elemente von Access zu referenzieren.<\/p>\n Wir machen ein kleines Beispiel, das die Möglichkeiten erahnen lässt. Wir wollen bei einem in der Formularansicht geöffneten Formular jeweils ermitteln, wie das Steuerelement mit dem Fokus heißt. Das wäre eine enorme Hilfe, weil man so beispielsweise schnell die passenden Ereignisse im VBA-Editor aufsuchen könnte.<\/p>\n Also ändern wir die onAction<\/b>-Prozedur in unserem Projekt wie folgt, um der Schaltfläche btnBeispiel1 <\/b>eine Funktion zuzuweisen:<\/p>\n Wir wollen also für die Schaltfläche btnBefehl1<\/b>, deren Name für die Eigenschaft Id <\/b>des Parameters control <\/b>übergeben wird, eine eigene Prozedur anlegen. Für alle anderen Schaltflächen unserer eigenen Ribbon-Definition soll die Callback-Funktion onAction <\/b>weiterhin einfach den Namen der Schaltfläche ausgeben.<\/p>\n Diese neue Prozedur soll wie folgt aussehen:<\/p>\n Wir weisen hier als Erstes der Variablen obj <\/b>mit dem Typ Object <\/b>das aktuelle Steuerelelement zu. Das setzt voraus, dass überhaupt ein Formular geöffnet ist, dass dann auch noch ein Steuerelement enthalten muss. Es kann aber auch sein, dass gerade kein Formular geöffnet ist – dann wird der Zugriff auf das aktuelle Steuerelement mit _Access.Screen.ActiveControl <\/b>einen Fehler auslösen. Den verhindern wir direkt durch die vorherige Anweisung On Error Resume Next<\/b>.<\/p>\n Ist obj <\/b>dann nicht leer, gibt die Prozedur per MsgBox <\/b>den Namen des aktuellen Steuerelements aus. Anderenfalls erscheint eine Meldung, dass kein Steuerelement aktiv ist.<\/p>\n Man könnte noch genauer aufschlüsseln und prüfen, ob überhaupt ein Formular geöffnet ist, aber das ist an dieser Stelle nicht wichtig.<\/p>\n Wichtig ist: Es funktioniert! Sie können so Befehle in einem COM-Add-In definieren, die über benutzerdefinierte Ribbon-Schaltflächen ausgelöst werden und mit denen Sie direkt die Elemente der aktuellen Anwendung erfassen oder anpassen können. <\/p>\n Wenn Sie nun noch auf die Daten der aktuellen Anwendung zugreifen wollen, benötigen Sie Zugriff über das Database<\/b>-Objekt dieser Datenbank.<\/p>\n Auch das ist grundsätzlich kein Problem, aber um die Elemente der DAO-Bibliothek zu verwenden, benötigen wir als Erstes wieder einen entsprechenden Verweis. Der heißt Microsoft DAO 3.6 Object Library <\/b>und ist schnell gesetzt, wie Bild 11 zeigt.<\/p>\n Bild 11: Verweis auf die DAO-Bibliothek hinzufügen<\/span><\/b><\/p>\n Hier zeigt sich, dass twinBASIC noch am Anfang ist: Bereits erstellte Bibliotheken tauchen gegebenenfalls mehrmals auf, weil diese noch nicht sauber aus der Registry entfernt werden.<\/p>\n Nach dem Hinzufügen der DAO-Bibliothek und – wichtig – dem Speichern der geänderten Einstellungen stehen die Elemente dieser Bibliothek für die Programmierung zur Verfügung.<\/p>\n Damit können wir die Umsetzung in Angriff nehmen. Die neue Prozedur sieht wie folgt aus und wird ähnlich wie die zuvor beschriebene von der Funktion onAction<\/b> aus aufgerufen:<\/p>\n In Bild 12 sehen Sie die Ausgabe durch diese Funktion des COM-Add-Ins. Es erscheinen wie gewünscht alle Tabellen im Meldungsfenster. In der Prozedur GetTables <\/b>haben wir keine Zauberei betrieben. Der Unterschied zu einer lokalen Prozedur dieser Art ist, dass wir hier nicht einfach auf die CurrentDb<\/b>-Funktion zugreifen, um eine Referenz auf das Database<\/b>-Objekt der aktuellen Datenbank zu erhalten. Stattdessen nutzen wir die CurrentDb<\/b>-Funktion der in _Access <\/b>gespeicherten Instanz des Access.Application<\/b>-Objekts.<\/p>\nKein 64-Bit unter Visual Studio 6<\/h2>\n
COM-Add-Ins mit twinBASIC<\/h2>\n
![\"Aufbau](\"..\/fileadmin\/_temp_\/2021_03\/pic_1306_002.png\")
<\/p>\nClass<\/span> MyAccessAddin\r\n Implements IDTExtensibility2\r\n Implements IRibbonExtensibility\r\n \r\n Private <\/span>_Access 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, _\r\n ByVal AddInInst As Object<\/span>, ByRef custom As Variant<\/span>()) _\r\n Implements IDTExtensibility2.OnConnection\r\n MsgBox<\/span> \"myAccessAddin.OnConnection\"\r\n Set<\/span> _Access = 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> \"myAccessAddin.OnDisconnection\"\r\n End SUb\r\n \r\n Sub OnAddInsUpdate(ByRef custom As Variant<\/span>()) _\r\n Implements IDTExtensibility2.OnAddInsUpdate\r\n MsgBox<\/span> \"myAccessAddin.OnAddInsUpdate\"\r\n End Sub\r\n \r\n Sub OnStartupComplete(ByRef custom As Variant<\/span>()) _\r\n Implements IDTExtensibility2.OnStartupComplete\r\n MsgBox<\/span> \"myAccessAddin.OnStartupComplete\"\r\n End Sub\r\n \r\n Sub OnBeginShutdown(ByRef custom As Variant<\/span>())_\r\n Implements IDTExtensibility2.OnBeginShutdown\r\n MsgBox<\/span> \"myAccessAddin.OnBeginShutdown\"\r\n End Sub\r\nEnd Class<\/span><\/pre>\nImplements IDTExtensibility2<\/pre>\n
![\"Notwendige](\"..\/fileadmin\/_temp_\/2021_03\/pic_1306_003.png\")
<\/p>\n\n
Private <\/span>_Access As <\/span>Access.Application<\/pre>\nPrivate <\/span>_AddIn As <\/span>COMAddIn<\/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> \"myAccessAddin.OnConnection\"\r\n Set<\/span> _Access = Application\r\n Set<\/span> _AddIn = AddInInst\r\nEnd Sub<\/span><\/pre>\nErstellen des COM-Add-Ins<\/h2>\n
![\"Ausgabe](\"..\/fileadmin\/_temp_\/2021_03\/pic_1306_009.png\")
<\/p>\nRegistrierung des COM-Add-Ins<\/h2>\n
Windows Registry Editor Version 5.00\r\n[HKEY_CURRENT_USER\\SOFTWARE\\Microsoft\\Office\\Access\\Addins\\MyAccessAddIn.MyAccessAddin]\r\n\"FriendlyName\"=\"MyAccessAddin (friendly name)\"\r\n\"Description\"=\"MyAccessAddin (description)\"\r\n\"LoadBehavior\"=dword:00000003<\/pre>\n
![\"Einträge](\"..\/fileadmin\/_temp_\/2021_03\/pic_1306_004.png\")
<\/p>\nErster Start des COM-Add-Ins<\/h2>\n
\n
Ribbon-Eintrag zum Steuern der Funktionen hinzufügen<\/h2>\n
Implements IRibbonExtensibility<\/pre>\n
[WithDispatchForwarding]\r\nImplements IRibbonExtensibility<\/pre>\n
Class<\/span> MyAccessAddin\r\n ... \r\n Private <\/span>Function IRibbonExtensibility_GetCustomUI( ByVal RibbonID As String<\/span>) As String<\/span>\r\n Dim <\/span>strXML As String<\/span>\r\n strXML = \"<customUI xmlns=\"\"http:\/\/schemas.microsoft.com\/office\/2006\/01\/customui\"\">\" & vbCrLf<\/span>\r\n strXML = strXML & \" <ribbon startFromScratch=\"\"false\"\">\" & vbCrLf<\/span>\r\n strXML = strXML & \" <tabs>\" & vbCrLf<\/span>\r\n strXML = strXML & \" <tab id=\"\"tabBeispiel\"\" label=\"\"COMAddIn\"\">\" & vbCrLf<\/span>\r\n strXML = strXML & \" <group id=\"\"grpBeispiel\"\" label=\"\"Funktionen\"\">\" & vbCrLf<\/span>\r\n strXML = strXML & \" <button id=\"\"btnBefehl1\"\" label=\"\"Befehl1\"\" onAction=\"\"onAction\"\" \" _\r\n & \"imageMso=\"\"BlogHomePage\"\" size=\"\"large\"\"\/>\" & vbCrLf<\/span>\r\n strXML = strXML & \" <button id=\"\"btnBefehl2\"\" label=\"\"Befehl2\"\" onAction=\"\"onAction\"\" \" _\r\n & \"imageMso=\"\"AccessTableEvents\"\" size=\"\"large\"\"\/>\" & vbCrLf<\/span>\r\n strXML = strXML & \" <button id=\"\"btnBefehl3\"\" label=\"\"Befehl3\"\" onAction=\"\"onAction\"\" \" _\r\n & \"imageMso=\"\"CustomTablesGallery\"\" size=\"\"large\"\"\/>\" & vbCrLf<\/span>\r\n strXML = strXML & \" <\/group>\" & vbCrLf<\/span>\r\n strXML = strXML & \" <\/tab>\" & vbCrLf<\/span>\r\n strXML = strXML & \" <\/tabs>\" & vbCrLf<\/span>\r\n strXML = strXML & \" <\/ribbon>\" & vbCrLf<\/span>\r\n strXML = strXML & \"<\/customUI>\" & vbCrLf<\/span>\r\n MsgBox<\/span> strXML\r\n IRibbonExtensibility_GetCustomUI = strXML\r\n End Function\r\nEnd Class<\/span><\/pre>\n![\"Ribbon-Befehle](\"..\/fileadmin\/_temp_\/2021_03\/pic_1306_005.png\")
<\/p>\nSub <\/span>onAction(control As <\/span>IRibbonControl)\r\n MsgBox<\/span> \"Sie haben folgende Ribbon-Schaltfläche angeklickt: ''\" & control.Id & \"''\"\r\nEnd Sub<\/span><\/pre>\n![\"Durch](\"..\/fileadmin\/_temp_\/2021_03\/pic_1306_006.png\")
<\/p>\nRegistrierung fixen<\/h2>\n
![\"Zurückgesetztes](\"..\/fileadmin\/_temp_\/2021_03\/pic_1306_007.png\")
<\/p>\n![\"Das](\"..\/fileadmin\/_temp_\/2021_03\/pic_1306_008.png\")
<\/p>\nNeuerstellen nach einem Fehler<\/h2>\n
![\"Fehler](\"..\/fileadmin\/_temp_\/2021_03\/pic_1306_010.png\")
<\/p>\nZugriff auf die Access-Instanz<\/h2>\n
Beispiele für den Zugriff auf die Access-Instanz<\/h2>\n
Sub <\/span>onAction(control As <\/span>IRibbonControl)\r\n Select Case Control.Id\r\n Case <\/span>\"btnBefehl1\"\r\n Call<\/span> GetControlname\r\n Case Else<\/span>\r\n MsgBox<\/span> \"Sie haben folgende Ribbon-Schaltfläche µ \r\n angeklickt: ''\" & control.Id & \"''\"\r\n End Select<\/span>\r\nEnd Sub<\/span><\/pre>\nSub <\/span>GetControlName()\r\n Dim <\/span>obj As Object<\/span>\r\n On Error Resume Next<\/span>\r\n Set<\/span> obj = _Access.Screen.ActiveControl\r\n If <\/span>Not<\/span> obj Is Nothing Then<\/span>\r\n MsgBox<\/span> \"Name des aktuellen Steuerelements: \" & obj.Name\r\n Else<\/span>\r\n MsgBox<\/span> \"Kein aktives Steuerelement.\"\r\n End If<\/span>\r\nEnd Sub<\/span><\/pre>\nAuf die Daten der Anwendung zugreifen<\/h2>\n
![\"Verweis](\"..\/fileadmin\/_temp_\/2021_03\/pic_1306_011.png\")
<\/p>\nSub <\/span>GetTables()\r\n Dim <\/span>db As <\/span>DAO.Database\r\n Dim <\/span>tdf As <\/span>DAO.TableDef\r\n Dim <\/span>strTables As String<\/span>\r\n On Error Resume Next<\/span>\r\n Set<\/span> db = _Access.CurrentDb\r\n If <\/span>db Is Nothing Then<\/span>\r\n MsgBox<\/span> \"Es ist keine Datenbank geöffnet.\"\r\n Else<\/span>\r\n For Each tdf In db.TableDefs\r\n strTables = strTables & tdf.Name & vbCrLf<\/span>\r\n Next<\/span> tdf \r\n MsgBox<\/span> strTables\r\n End If<\/span>\r\nEnd Sub<\/span><\/pre>\n![\"Ausgabe](\"..\/fileadmin\/_temp_\/2021_03\/pic_1306_012.png\")
<\/p>\n