![\"Neuer](\"..\/fileadmin\/_temp_\/2026_04\/pic_1607_001.png\")
<\/p>\nIm Beitrag „Access: Version und Architektur einfach ermitteln“ (www.access-im-unternehmen.de\/1606) haben wir die neuen SysCmd-Konstanten zum Abfragen von Access-Version und Access-Architektur vorgestellt. Dort haben wir auch gezeigt, wie wir diese Informationen übersichtlich in einem Formular darstellen können. Im vorliegenden Beitrag erstellen wir nun ein COM-Add-In, das den Dateibereich von Access erweitert und dort die verschiedenen Versionsinformationen, die Architektur und den aktuellen Update-Kanal von Access anzeigt. Außerdem liefern wir dort auch gleich noch den aktuellen Datenbankpfad und eine Möglichkeit, diesen in die Zwischenablage zu kopieren.<\/b><\/p>\n
Die neuen SysCmd<\/b>-Konstanten wie acSysCmdGetMsoBuildNumber <\/b>oder acSysCmdGetBitness <\/b>bieten uns die Möglichkeit, Versionsinformationen oder die Architektur der aktuellen Installation von Microsoft Access per VBA zu ermitteln.<\/p>\n
Damit erhalten wir eine Alternative dazu, die Informationen umständlich über das Datei-Menü von Access zu ermitteln. Wenn wir allerdings die Version und die Bitness der Anwendung eines Kunden abfragen wollen, ist es wohl ebenso umständlich, diesem die entsprechende SysCmd<\/b>-Anweisung zur Eingabe in den Direktbereich des VBA-Editors zu diktieren und uns das Ergebnis mitteilen zu lassen.<\/p>\n
Da wir in früheren Beiträgen bereits einige COM-Add-Ins mit dem zumindest für die 32-Bit-Version kostenlosen twinBASIC programmiert haben (das Kompilieren von 64-Bit-COM-Add-Ins ist auch möglich, allerdings wird dort bei jedem Start ein Spash-Screen eingeblendet), wollen wir hier ein weiteres Beispiel dafür liefern, wie man die Benutzerumgebung von Access selbst um praktische Funktionen erweitern kann.<\/p>\n
Das Ergebnis sehen wir vorab in Bild 1. Wenn der Benutzer im Ribbon auf Datei klickt, findet er im Datei-Menü direkt einen Eintrag namens amvAccessSpecs. Dahinter zeigt sich die Ansicht mit den Access-Spezifikationen, die wir überwiegend mit den neuen SysCmd-Konstanten ermittelt haben.<\/p>\n
<\/p>\n
Bild 1: Neuer Bereich im Datei-Abschnitt des Ribbons von Microsoft Access<\/span><\/b><\/p>\n Außerdem haben wir noch den aktuellen Datenbankpfad hinzugefügt, den wir entweder markieren und kopieren oder auch direkt im Windows Explorer öffnen können.<\/p>\n An dieser Stelle wollen wir uns die Beschreibung sparen, wie das vollständige COM-Add-In auf Basis der Vorlage Sample 5 – MyCOMAddIn <\/b>erstellen – letztlich müssen wir dort nur den anschließend vorgestellten Code ersetzen.<\/p>\n Also empfehlen wir, zum Studium und für eigene Anpassungen einfach das mit dem Download gelieferte twinBASIC-Projekt namens amvAccessSpecs.twinproj <\/b>zu nutzen.<\/p>\n Die Auflistung der Versionen von twinBASIC finden Sie unter dem folgenden Link:<\/p>\n Hier klicken wir auf die aktuellste Version und laden diese wie in Bild 2 herunter – hier die Version twinBASIC BETA 983<\/b>.<\/p>\n Bild 2: Herunterladen der aktuellen twinBASIC-Version<\/span><\/b><\/p>\n Und keine Sorge wegen des Beta-Status – die damit erzeugten COM-Add-Ins funktionieren einwandfrei.<\/p>\n In den Projekteigenschaften haben wir Projekt Name<\/b>, Project Description <\/b>und Application Title <\/b>jeweils auf amvAccessSpecs <\/b>eingestellt.<\/p>\n Außerdem benötigen wir Verweise auf die Bibliotheken Microsoft Office 16.0 Object Library <\/b>und Microsoft Access 16.0 Object Library<\/b>.<\/p>\n Der Code, der das COM-Add-In beim Starten von Access lädt und für die Anzeige des neuen Bereichs im Backstage sorgt, befindet sich im Modul amvAccessSpecs.twin<\/b>.<\/p>\n Diesen öffnen wir durch einen Doppelklick auf den entsprechenden Eintrag im Projektexplorer (siehe Bild 3).<\/p>\n Bild 3: Überblick des Projekts und das Modul amvAccessSpecs.twin<\/span><\/b><\/p>\n Wir schauen uns den Code nun Schritt für Schritt an.<\/p>\n Im oberen Bereich des Moduls finden wir die Deklaration der Klasse amvAccessSpecs<\/b> samt den beiden Schnittstellen, die sie umsetzt.<\/p>\n Ganz oben sehen wir die ClassId<\/b>:<\/p>\n Die ClassId <\/b>ist die eindeutige Identität der COM-Klasse – ein weltweit einmaliger Schlüssel (eine GUID), unter dem Windows das COM-Add-In in der Registry findet und startet.<\/p>\n Der Hintergrund: COM-Objekte werden nicht über ihren Namen angesprochen, sondern über diese GUID (CLSID genannt). Wenn Access das Add-In lädt, schaut es in der Registry unter genau dieser Nummer nach, wo die zugehörige Datei liegt und welche Klasse zu instanziieren ist. Der Klassenname amvAccessSpecs <\/b>ist nur für uns als Entwickler da; Windows arbeitet intern mit der GUID.<\/p>\n Deshalb ist zweierlei wichtig: Die Nummer muss wirklich einmalig sein (twinBASIC erzeugt sie zufällig, die Wahrscheinlichkeit einer Kollision ist praktisch null), und sie sollte stabil bleiben. Ändern wir sie nachträglich, gilt das Add-In für Windows als ein völlig anderes Objekt – die alte Registrierung zeigt dann ins Leere, und wir müssten neu registrieren. Beim Weitergeben oder Aktualisieren des Add-Ins lassen wir die ClassId <\/b>also unverändert.<\/p>\n Kurz gesagt: Sie ist der Personalausweis der Klasse, über den COM sie zweifelsfrei wiederfindet.<\/p>\n Anschließend folgt die Definition der Klasse amvAccessSpecs <\/b>selbst mit den beiden Schnittstellen, die sie implementiert:<\/p>\n Eine Schnittstelle ist so etwas wie ein Versprechen: Wer sie umsetzt, sagt zu, bestimmte Prozeduren bereitzustellen. IDTExtensibility2<\/b> sorgt dafür, dass Office unser Add-In starten und beenden kann. IRibbonExtensibility<\/b> erlaubt es uns, dem Menüband – genauer dem Datei-Menü – etwas hinzuzufügen.<\/p>\n Die Zeile Friend objAccess As Access.application<\/b> legt außerdem eine Variable an, in der wir gleich einen Verweis auf Access selbst ablegen. Über diese stellen wir Access später unsere Fragen nach Version und Architektur. Die Angaben in eckigen Klammern sind technische Markierungen, die twinBASIC für ein COM-Add-In benötigt; um sie müssen wir uns nicht kümmern.<\/p>\n Sobald Access startet und unser Add-In verbindet, ruft es die Prozedur OnConnection<\/b> auf. Genau hier merken wir uns den Verweis auf Access (siehe Listing 1).<\/p>\n Listing 1: Beim Verbinden den Verweis auf Access merken<\/span><\/b><\/p>\n Set objAccess = Application<\/b> speichert einen Verweis auf die übergebene Anwendung in unserer Variablen. Die Schnittstelle IDTExtensibility2<\/b> verlangt noch vier weitere Prozeduren – OnDisconnection<\/b>, OnAddInsUpdate<\/b>, OnStartupComplete<\/b> und OnBeginShutdown<\/b> -, die wir hier aber leer lassen, weil wir sie nicht benötigen. Sie müssen aber angelegt sein.<\/p>\n Wie unser Bereich im Datei-Menü aussieht, beschreiben wir als XML-Definition. Die Funktion GetCustomUI<\/b> baut diesen Text Zeile für Zeile zusammen und gibt ihn an Access zurück (siehe Listing 2).<\/p>\n Listing 2: Die Funktion GetCustomUI stellt die Oberfläche wird als XML zusammen<\/span><\/b><\/p>\n Das hat einen Vorteil: Wir bestimmen damit ganz genau, welche Felder und Schaltflächen erscheinen und wie sie angeordnet sind. Die Funktion GetCustomUI<\/b> baut diese Beschreibung Zeile für Zeile zusammen und gibt sie an Access zurück.<\/p>\n Ganz außen steht das Element customUI<\/b>. Es ist die Klammer um alles Weitere und nennt mit onLoad<\/b> die Prozedur, die Access einmal aufrufen soll, sobald die Oberfläche geladen ist.<\/p>\n Darin folgt backstage<\/b> – und das ist genau der Bereich, der erscheint, wenn der Benutzer links oben auf Datei<\/b> klickt, nicht eine der gewöhnlichen Registerkarten des Menübands.<\/p>\n Im backstage<\/b> legen wir mit tab<\/b> unsere eigene Seite an. Sie trägt die Beschriftung amvAccessSpecs<\/b>, und mit der Angabe insertAfterMso<\/b> samt dem Wert TabInfo<\/b> schieben wir sie genau hinter den bereits vorhandenen Bereich Informationen<\/b>. So fügt sich unser Eintrag nahtlos in das gewohnte Datei-Menü ein.<\/p>\n Innerhalb dieser Seite ordnen wir den Inhalt in zwei Gruppen: Version und Architektur<\/b> und Weitere Informationen<\/b>. Eine Gruppe ist dabei nichts weiter als ein zusammengehöriger Block mit einer Überschrift. Die eigentliche Anordnung der Felder übernimmt in jeder Gruppe ein layoutContainer<\/b>.<\/p>\n Über dessen Angabe legen wir fest, ob die enthaltenen Elemente untereinander (vertical<\/b>) oder nebeneinander (horizontal<\/b>) stehen. Die vielen Versionsfelder stapeln wir untereinander; das Pfadfeld und die Öffnen-Schaltfläche dagegen setzen wir nebeneinander.<\/p>\n Die einzelnen Anzeigefelder sind Elemente vom Typ editBox<\/b>. Jedes bekommt eine eigene Kennung (id<\/b>), eine Beschriftung (label<\/b>) und über sizeString<\/b> eine feste Breite – dafür geben wir schlicht eine Kette von W<\/b>-Buchstaben an, die so breit ist, wie das Feld später sein soll.<\/p>\n Und jedes Feld nennt mit getText<\/b> die Funktion, die seinen Inhalt liefert.<\/p>\n In der zweiten Gruppe kommt neben dem Pfadfeld noch eine Schaltfläche hinzu, das Element button<\/b>. Sie zeigt über imageMso<\/b> ein vorhandenes Office-Symbol – hier FileOpen<\/b>, das Symbol zum Öffnen – und ruft über onAction<\/b> beim Anklicken unsere Prozedur btnOpenDatabaseFolder_onAction<\/b> auf.<\/p>\n Der eigentliche Kniff an dieser Beschreibung: Sie sagt nur, welche Felder es gibt und wie sie aussehen – nicht, was darin steht. Den Inhalt holt sich jedes Feld selbst, indem es über seine id<\/b> die Funktion getText<\/b> befragt; ebenso meldet sich die Schaltfläche über onAction<\/b>, sobald sie geklickt wird. So bleiben Aussehen und Inhalt sauber getrennt: Die XML-Definition kümmert sich um die Optik, der VBA-Code um die Werte.<\/p>\n Wenn Office unsere Oberfläche geladen hat, ruft es einmal die Funktion customUI_OnLoad<\/b> auf. Darin merken wir uns das Menüband in der Variablen m_ribbon<\/b>:<\/p>\n Nun zum Herzstück. Jedes Textfeld ruft beim Anzeigen die Funktion getText<\/b> auf und gibt dabei seine eigene Kennung mit. Anhand dieser Kennung liefern wir den passenden Wert zurück, wie Listing 3 zeigt. Die eigentlichen Angaben holen wir uns über die neuen SysCmd<\/b>-Konstanten. Jede Kennung steht für eine bestimmte Information:<\/p>\n Listing 3: Die Funktion getText füllt die Textfelder.<\/span><\/b><\/p>\n Liefert eine dieser Abfragen einen leeren Text, zeigen wir stattdessen Nicht verfügbar<\/b> an – so bleibt kein Feld leer.<\/p>\n Bleibt die Schaltfläche neben dem Datenbankpfad. Ein Klick darauf ruft die Prozedur btnOpenDatabaseFolder_onAction<\/b> auf:<\/p>\n Wir holen uns den Pfad der aktuellen Datenbank, prüfen mit Dir<\/b>, ob der Ordner wirklich existiert, und öffnen ihn dann mit Shell<\/b> und explorer.exe<\/b> in einem neuen Fenster.<\/p>\n Damit Access unser Add-In beim Start überhaupt findet, muss es in der Windows-Registry eingetragen sein. Genau darum kümmert sich das Modul DllRegistration<\/b>.<\/p>\n Es enthält zwei Funktionen: eine zum Eintragen und eine zum Entfernen. Ihre Namen sind nicht frei gewählt, sondern fest vorgegeben – dazu am Ende mehr.<\/p>\n Am Anfang des Moduls legen wir vier Konstanten fest (siehe Listing 4).<\/p>\n Listing 4: Die Konstanten des Registrierungsmoduls<\/span><\/b><\/p>\n AddinProjectName<\/b> übernimmt über VBA.Compilation.CurrentProjectName<\/b> schlicht den Namen des Projekts, also amvAccessSpecs<\/b>. AddinQualifiedClassName<\/b> ermittelt mit GetDeclaredTypeProgId<\/b> die sogenannte ProgID unserer Klasse – den sprechenden Namen, unter dem COM sie kennt. Beide Werte stehen bereits zur Übersetzungszeit fest.<\/p>\n Aus der ProgID setzen wir die Registry-Pfade zusammen. RootRegistryFolder_ACCESS<\/b> zeigt auf den Ort, an dem Access nach seinen COM-Add-Ins sucht: unterhalb von HKCU<\/b> – dem Zweig des aktuellen Benutzers – im Bereich der Office-Add-Ins.<\/p>\n Die erste Funktion trägt unser Add-In ein, wie Listing 5 zeigt.<\/p>\n Listing 5: Die Registry-Einträge anlegen<\/span><\/b><\/p>\n Wir erzeugen ein wscript.shell<\/b>-Objekt und schreiben damit drei Werte unter den Access-Schlüssel: FriendlyName<\/b> und Description<\/b> erhalten beide den Projektnamen, und LoadBehavior<\/b> bekommt den Wert 3<\/b>.<\/p>\n Dieser Wert ist entscheidend – er bedeutet, dass Access das Add-In gleich beim Start laden soll.<\/p>\n Da wir in HKCU<\/b> schreiben, also im Benutzerzweig, sind dafür keine Administratorrechte nötig. Geht beim Schreiben etwas schief, springt die Ausführung zur Marke RegError<\/b>, zeigt eine Meldung mit Fehlerbeschreibung und Fehlernummer und liefert False<\/b>; im Normalfall gibt die Funktion True<\/b> zurück.<\/p>\n Das Gegenstück löscht die Einträge wieder (siehe Listing 6).<\/p>\n Listing 6: Die Registry-Einträge wieder entfernen<\/span><\/b><\/p>\n Hier löschen wir mit RegDelete<\/b> zuerst die drei Werte und anschließend den Schlüssel selbst. Die Fehlerbehandlung arbeitet genauso wie beim Eintragen.<\/p>\n Die Namen DllRegisterServer<\/b> und DllUnregisterServer<\/b> sind fest vorgegeben: COM erwartet genau diese beiden Funktionen, wenn sich eine DLL selbst registrieren soll. twinBASIC macht sich das zunutze.<\/p>\n Kompilieren wir das Projekt und lassen es registrieren, meldet twinBASIC zum einen die COM-Klasse an und ruft zum anderen unsere Funktion DllRegisterServer<\/b> auf – diese schreibt dann die beschriebenen Einträge. Damit ist das Add-In sofort einsatzbereit, und Access lädt es beim nächsten Start. Beim Aufheben der Registrierung ruft twinBASIC entsprechend DllUnregisterServer<\/b> auf.<\/p>\n Auf einem anderen Rechner – etwa beim Kunden – geben wir die fertige DLL weiter und registrieren sie mit dem Windows-Werkzeug regsvr32<\/b>. Rufen wir regsvr32 amvAccessSpecs.dll<\/b> auf, lädt regsvr32 <\/b>die DLL und ruft genau unsere Funktion DllRegisterServer<\/b> auf – es läuft also derselbe Code wie beim Kompilieren.<\/p>\n Mit regsvr32 \/u amvAccessSpecs.dll<\/b> geht es andersherum: regsvr32<\/b> ruft DllUnregisterServer<\/b> auf und entfernt die Einträge wieder.<\/p>\n Ein Punkt ist dabei wichtig: regsvr32 <\/b>und die DLL müssen zur selben Architektur gehören. Eine 32-Bit-DLL registrieren wir mit dem 32-Bit-regsvr32<\/b> aus dem Ordner SysWOW64<\/b>, eine 64-Bit-DLL mit dem 64-Bit-regsvr32<\/b>. Passt die Bitness nicht zusammen, verweigert regsvr32 <\/b>die Arbeit.<\/p>\n So genügt derselbe kleine Code sowohl während der Entwicklung in twinBASIC als auch bei der späteren Verteilung per regsvr32<\/b>.<\/p>\n Um die 64-Bit-Version zu kompilieren, stellen wir oben im twinBASIC von win32 <\/b>auf win64 <\/b>um (siehe Bild 4).<\/p>\n Bild 4: Kompilieren für 32-Bit- und 64-Bit-Access<\/span><\/b><\/p>\n Das Kompilieren selbst erledigen wir mit dem Menübefehl File|Build<\/b>.<\/p>\n Danach steht das COM-Add-In beim nächsten Start von Access bereits zur Verfügung. Wichtig ist, dass wir nicht neu kompilieren, während das COM-Add-In in Access geöffnet ist – dann erhalten wir eine Fehlermeldung.<\/p>\n Wenn Sie das COM-Add-In selbst um weitere Elemente erweitern wollen, sind Änderungen an zwei Stellen nötig.<\/p>\n Angenommen, wir wollen auch noch den Namen der Access-Datenbankdatei abbilden.<\/p>\n Dann fügen wir zuerst ein entsprechendes editBox<\/b>-Element zur XML-Definition hinzu, zum Beispiel unter dem layoutContainer<\/b>-Element lcDatabaseFolder <\/b>in einem neuen layoutContainer-Element (siehe Listing 7).<\/p>\n Listing 7: Hinzufügen eines neuen Text-Elements<\/span><\/b><\/p>\n Außerdem erweitern wir die Funktion getText<\/b> um den folgenden Case<\/b>-Zweig – hier weisen wir mit CurrentProject.Name <\/b>den Namen der Datenbankdatei zu:<\/p>\n Kompilieren wir das Projekt nun erneut und öffnen den entsprechenden Bereich in Access, sehen wir das neue Steuerelement mit dem entsprechenden Eintrag (siehe Bild 5).<\/p>\n Bild 5: Neuer Eintrag in den Access-Spezifikationen<\/span><\/b><\/p>\n Auf diese Weise können wir beliebige Informationen, die wir aus Access auslesen können, über unser COM-Add-In sichtbar machen.<\/p>\n Dieser Beitrag zeigt, wie wir den Datei-Bereich von Access um eine eigene Sektion erweitern können, in der wir verschiedene Informationen und Steuerelelemente unterbringen.<\/p>\n In diesem Fall haben wir die neuen SysCmd<\/b>-Konstanten genutzt, um Informationen über die Version und die Architektur der aktuell installierten Access-Anwendung übersichtlich und mit wenigen Mausklicks darstellen können.<\/p>\n Außerdem haben wir gezeigt, wie dieses COM-Add-In einfach um eigene Steuerelemente erweitert werden kann.<\/p>\n Weitere Ideen zur Erweiterung sind ein Button zum Komprimieren und Reparieren einer Anwendung oder auch zum Anzeigen von Statistiken wie etwa die Anzahl von Tabellen, Abfragen, Formularen, Berichten et cetera.<\/p>\n","protected":false},"excerpt":{"rendered":" Im Beitrag „Access: Version und Architektur einfach ermitteln“ (www.access-im-unternehmen.de\/1606) haben wir die neuen SysCmd-Konstanten zum Abfragen von Access-Version und Access-Architektur vorgestellt. Dort haben wir auch gezeigt, wie wir diese Informationen übersichtlich in einem Formular darstellen können. Im vorliegenden Beitrag erstellen wir nun ein COM-Add-In, das den Dateibereich von Access erweitert und dort die verschiedenen Versionsinformationen, die Architektur und den aktuellen Update-Kanal von Access anzeigt. Außerdem liefern wir dort auch gleich noch den aktuellen Datenbankpfad und eine Möglichkeit, diesen in die Zwischenablage zu kopieren.<\/p>\n","protected":false},"author":1,"featured_media":0,"comment_status":"open","ping_status":"open","sticky":false,"template":"","format":"standard","meta":{"om_disable_all_campaigns":false,"_monsterinsights_skip_tracking":false,"_monsterinsights_sitenote_active":false,"_monsterinsights_sitenote_note":"","_monsterinsights_sitenote_category":0,"_uf_show_specific_survey":0,"_uf_disable_surveys":false,"footnotes":""},"categories":[662026,66042026,44000027],"tags":[],"class_list":["post-55001607","post","type-post","status-publish","format-standard","hentry","category-662026","category-66042026","category-Loesungen"],"yoast_head":"\nFunktionsweise des COM-Add-Ins<\/h2>\n
https:\/\/github.com\/twinbasic\/twinbasic\/releases<\/pre>\n
![\"Herunterladen](\"..\/fileadmin\/_temp_\/2026_04\/pic_1607_002.png\")
<\/p>\nProjekteigenschaften<\/h2>\n
Code des COM-Add-Ins<\/h2>\n
![\"Überblick](\"..\/fileadmin\/_temp_\/2026_04\/pic_1607_003.png\")
<\/p>\nDie Klasse und ihre Schnittstellen<\/h2>\n
[ClassId(\"319E65DE-8BB5-4F-890C-598D98FCCC22\")]<\/pre>\n
Public Class<\/span> amvAccessSpecs\r\n Implements IDTExtensibility2\r\n [WithDispatchForwarding]\r\n Implements IRibbonExtensibility\r\n Friend objAccess As <\/span>Access.application<\/pre>\nWenn Access das Add-In lädt<\/h2>\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> objAccess = Application\r\nEnd Sub<\/span><\/pre>\nDie Oberfläche im Datei-Menü<\/h2>\n
Private Function <\/span>GetCustomUI(ByVal RibbonID As String<\/span>) As String<\/span> Implements IRibbonExtensibility.GetCustomUI\r\n Dim <\/span>strXML As String<\/span>\r\n strXML = \"<customUI xmlns=\"\"http:\/\/schemas.microsoft.com\/office\/2009\/07\/customui\"\" onLoad=\"\"customUI_OnLoad\"\">\" & vbCrLf<\/span>\r\n strXML = strXML & \" <backstage>\" & vbCrLf<\/span>\r\n strXML = strXML & \" <tab id=\"\"tabSQLServer\"\" label=\"\"amvAccessSpecs\"\" insertAfterMso=\"\"TabInfo\"\" \" _\r\n & \"title=\"\"Access-Spezifikationen\"\">\" & vbCrLf<\/span>\r\n strXML = strXML & \" <firstColumn>\" & vbCrLf<\/span>\r\n strXML = strXML & \" <group id=\"\"grpVersionsUndArchitektur\"\" label=\"\"Version und Architektur\"\">\" & vbCrLf<\/span>\r\n strXML = strXML & \" <topItems>\" & vbCrLf<\/span>\r\n strXML = strXML & \" <layoutContainer id=\"\"lcTreiber\"\" layoutChildren=\"\"vertical\"\">\" & vbCrLf<\/span>\r\n strXML = strXML & \" <editBox id=\"\"ebFullVersion\"\" label=\"\"Volle Version\"\" \" _\r\n & \"sizeString=\"\"WWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWW\"\" getText=\"\"getText\"\"\/>\" & vbCrLf<\/span>\r\n strXML = strXML & \" <editBox id=\"\"ebVersion\"\" label=\"\"Version\"\" \" _\r\n & \"sizeString=\"\"WWWWWWWWWWWWWWWWWWWW\"\" getText=\"\"getText\"\"\/>\" & vbCrLf<\/span>\r\n strXML = strXML & \" <editBox id=\"\"ebAccessVer\"\" label=\"\"Access-Version\"\" \" _\r\n & \"sizeString=\"\"WWWWWWWWWWWWWWWWWWWW\"\" getText=\"\"getText\"\"\/>\" & vbCrLf<\/span>\r\n strXML = strXML & \" <editBox id=\"\"ebMsoBuildNumber\"\" label=\"\"MSO-Buildnummer\"\" \" _\r\n & \"sizeString=\"\"WWWWWWWWWWWWWWWWWWWW\"\" getText=\"\"getText\"\"\/>\" & vbCrLf<\/span>\r\n strXML = strXML & \" <editBox id=\"\"ebFullBuildNumber\"\" label=\"\"Volle Buildnummer\"\" \" _\r\n & \"sizeString=\"\"WWWWWWWWWWWWWWWWWWWW\"\" getText=\"\"getText\"\"\/>\" & vbCrLf<\/span>\r\n strXML = strXML & \" <editBox id=\"\"ebChannelName\"\" label=\"\"Channel-Name\"\" \" _\r\n & \"sizeString=\"\"WWWWWWWWWWWWWWWWWWWW\"\" getText=\"\"getText\"\"\/>\" & vbCrLf<\/span>\r\n strXML = strXML & \" <editBox id=\"\"ebBitness\"\" label=\"\"Architektur\"\" \" _\r\n & \"sizeString=\"\"WWWWWWWWWWWWWWWWWWWW\"\" getText=\"\"getText\"\"\/>\" & vbCrLf<\/span>\r\n strXML = strXML & \" <editBox id=\"\"ebBuildNumber\"\" label=\"\"Buildnummer\"\" \" _\r\n & \"sizeString=\"\"WWWWWWWWWWWWWWWWWWWW\"\" getText=\"\"getText\"\"\/>\" & vbCrLf<\/span>\r\n strXML = strXML & \" <\/layoutContainer>\" & vbCrLf<\/span>\r\n strXML = strXML & \" <\/topItems>\" & vbCrLf<\/span>\r\n strXML = strXML & \" <\/group>\" & vbCrLf<\/span>\r\n strXML = strXML & \" <group id=\"\"grpWeitereInformationen\"\" label=\"\"Weitere Informationen\"\">\" & vbCrLf<\/span>\r\n strXML = strXML & \" <topItems>\" & vbCrLf<\/span>\r\n strXML = strXML & \" <layoutContainer id=\"\"lcWeitereInformationen\"\" layoutChildren=\"\"vertical\"\">\" & vbCrLf<\/span>\r\n strXML = strXML & \" <layoutContainer id=\"\"lcDatabaseFolder\"\" layoutChildren=\"\"horizontal\"\">\" & vbCrLf<\/span>\r\n strXML = strXML & \" <editBox id=\"\"ebDatabaseFolder\"\" label=\"\"Datenbankorder\"\" \" _\r\n & \"sizeString=\"\"WWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWW\"\" getText=\"\"getText\"\"\/>\" & vbCrLf<\/span>\r\n strXML = strXML & \" <button id=\"\"btnOpenDatabaseFolder\"\" label=\"\"Öffnen\"\" \" _\r\n & \"imageMso=\"\"FileOpen\"\" onAction=\"\"btnOpenDatabaseFolder_onAction\"\"\/>\" & vbCrLf<\/span>\r\n strXML = strXML & \" <\/layoutContainer>\" & vbCrLf<\/span>\r\n strXML = strXML & \" <\/layoutContainer>\" & vbCrLf<\/span>\r\n strXML = strXML & \" <\/topItems>\" & vbCrLf<\/span>\r\n strXML = strXML & \" <\/group>\" & vbCrLf<\/span>\r\n strXML = strXML & \" <\/firstColumn>\" & vbCrLf<\/span>\r\n strXML = strXML & \" <\/tab>\" & vbCrLf<\/span>\r\n strXML = strXML & \" <\/backstage>\" & vbCrLf<\/span>\r\n strXML = strXML & \"<\/customUI>\" & vbCrLf<\/span>\r\n Return strXML\r\nEnd Function<\/span><\/pre>\nDer Ribbon meldet sich<\/h2>\n
Private <\/span>m_ribbon As <\/span>IRibbonUI\r\nPublic Function <\/span>customUI_OnLoad(ribbon As <\/span>IRibbonUI) _\r\n As <\/span>IRibbonUI\r\n Set<\/span> m_ribbon = ribbon\r\n On Error Resume Next<\/span>\r\nEnd Function<\/span><\/pre>\nWoher die Werte kommen<\/h2>\n
Public Function <\/span>getText(control As <\/span>IRibbonControl) As String<\/span>\r\n Dim <\/span>strText As String<\/span>\r\n On Error Resume Next<\/span>\r\n Select Case control.Id\r\n Case <\/span>\"ebAccessVer\"\r\n strText = objAccess.SysCmd(7) 'acSysCmdAccessVer\r\n Case <\/span>\"ebMsoBuildNumber\"\r\n strText = objAccess.SysCmd(715) 'acSysCmdGetMsoBuildNumber\r\n If <\/span>Len<\/span>(strText) = 0 Then<\/span>\r\n strText = \"Nicht verfügbar.\"\r\n End If<\/span>\r\n Case <\/span>\"ebFullVersion\"\r\n strText = objAccess.SysCmd(720) 'acSysCmdGetFullVersion\r\n If <\/span>Len<\/span>(strText) = 0 Then<\/span>\r\n strText = \"Nicht verfügbar.\"\r\n End If<\/span>\r\n Case <\/span>\"ebVersion\"\r\n strText = objAccess.SysCmd(721) 'acSysCmdGetVersion\r\n If <\/span>Len<\/span>(strText) = 0 Then<\/span>\r\n strText = \"Nicht verfügbar.\"\r\n End If<\/span>\r\n Case <\/span>\"ebFullBuildNumber\"\r\n strText = objAccess.SysCmd(722) 'acSysCmdGetFullBuildNumber\r\n If <\/span>Len<\/span>(strText) = 0 Then<\/span>\r\n strText = \"Nicht verfügbar.\"\r\n End If<\/span>\r\n Case <\/span>\"ebChannelName\"\r\n strText = objAccess.SysCmd(723) 'acSysCmdGetChannelName\r\n If <\/span>Len<\/span>(strText) = 0 Then<\/span>\r\n strText = \"Nicht verfügbar.\"\r\n End If<\/span>\r\n Case <\/span>\"ebBitness\"\r\n strText = objAccess.SysCmd(724) 'acSysCmdGetBitness\r\n If <\/span>Len<\/span>(strText) = 0 Then<\/span>\r\n strText = \"Nicht verfügbar.\"\r\n End If<\/span>\r\n Case <\/span>\"ebBuildNumber\"\r\n strText = objAccess.SysCmd(725) 'acSysCmdGetBuildNumber\r\n If <\/span>Len<\/span>(strText) = 0 Then<\/span>\r\n strText = \"Nicht verfügbar.\"\r\n End If<\/span>\r\n Case <\/span>\"ebDatabaseFolder\"\r\n strText = objAccess.CurrentProject.Path\r\n End Select<\/span>\r\n Return strText\r\nEnd Function<\/span><\/pre>\n\n
Den Ordner öffnen<\/h2>\n
Public Sub <\/span>btnOpenDatabaseFolder_onAction(ByVal control _\r\n As <\/span>Office.IRibbonControl)\r\n Dim <\/span>strFolder As String<\/span>\r\n strFolder = objAccess.CurrentProject.Path\r\n If <\/span>Len<\/span>(strFolder) > 0 Then<\/span>\r\n If <\/span>Len<\/span>(Dir(strFolder, vbDirectory)) > 0 Then<\/span>\r\n Shell \"explorer.exe \"\"\" & strFolder _\r\n & \"\"\"\", vbNormalFocus\r\n End If<\/span>\r\n End If<\/span>\r\nEnd Sub<\/span><\/pre>\nDas Add-In bekannt machen<\/h2>\n
Die Konstanten<\/h2>\n
Const AddinProjectName As String<\/span> = VBA.Compilation.CurrentProjectName\r\nConst AddinQualifiedClassName As String<\/span> = GetDeclaredTypeProgId(Of amvAccessSpecs.amvAccessSpecs)\r\nConst RootRegistryFolder_ACCESS As String<\/span> = \"HKCU\\SOFTWARE\\Microsoft\\Office\\Access\\Addins\\\" & AddinQualifiedClassName & \"\\\"\r\nConst RootRegistryFolder_EXCEL As String<\/span> = \"HKCU\\SOFTWARE\\Microsoft\\Office\\Excel\\Addins\\\" & AddinQualifiedClassName & \"\\\"<\/pre>\nEintragen mit DllRegisterServer<\/h2>\n
Public Function <\/span>DllRegisterServer() As Boolean<\/span>\r\n On Error GoTo<\/span> RegError\r\n Dim <\/span>wscript As Object<\/span> = CreateObject(\"wscript.shell\")\r\n wscript.RegWrite RootRegistryFolder_ACCESS & \"FriendlyName\", AddinProjectName, \"REG_SZ\"\r\n wscript.RegWrite RootRegistryFolder_ACCESS & \"Description\", AddinProjectName, \"REG_SZ\"\r\n wscript.RegWrite RootRegistryFolder_ACCESS & \"LoadBehavior\", 3, \"REG_DWORD\"\r\n Return True<\/span>\r\nRegError:\r\n MsgBox<\/span> \"DllRegisterServer -- An error occured trying to write to the system registry:\" & vbCrLf<\/span> & _\r\n Err.Description & \" (\" & Hex(Err.Number) & \")\"\r\n Return False<\/span>\r\nEnd Function<\/span><\/pre>\nEntfernen mit DllUnregisterServer<\/h2>\n
Public Function <\/span>DllUnregisterServer() As Boolean<\/span>\r\n On Error GoTo<\/span> RegError\r\n Dim <\/span>wscript As Object<\/span> = CreateObject(\"wscript.shell\")\r\n wscript.RegDelete RootRegistryFolder_ACCESS & \"FriendlyName\"\r\n wscript.RegDelete RootRegistryFolder_ACCESS & \"Description\"\r\n wscript.RegDelete RootRegistryFolder_ACCESS & \"LoadBehavior\"\r\n wscript.RegDelete RootRegistryFolder_ACCESS\r\n Return True<\/span>\r\nRegError:\r\n MsgBox<\/span> \"DllUnregisterServer -- An error occured trying to delete from the system registry:\" & vbCrLf<\/span> & _\r\n Err.Description & \" (\" & Hex(Err.Number) & \")\"\r\n Return False<\/span>\r\nEnd Function<\/span><\/pre>\nWas beim Kompilieren aus twinBASIC passiert<\/h2>\n
Was regsvr32 damit macht<\/h2>\n
![\"Kompilieren](\"..\/fileadmin\/_temp_\/2026_04\/pic_1607_004.png\")
<\/p>\nErweitern des COM-Add-Ins um weitere Informationen<\/h2>\n
strXML = strXML & \" <layoutContainer id=\"\"lcDatabaseName\"\" layoutChildren=\"\"horizontal\"\">\" & vbCrLf<\/span>\r\nstrXML = strXML & \" <editBox id=\"\"ebDatabaseName\"\" label=\"\"Datenbankname\"\" \" _\r\n & \"sizeString=\"\"WWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWWW\"\" getText=\"\"getText\"\"\/>\" & vbCrLf<\/span>\r\nstrXML = strXML & \" <\/layoutContainer>\" & vbCrLf<\/span><\/pre>\nCase <\/span>\"ebDatabaseName\"\r\n strText = objAccess.CurrentProject.Name<\/pre>\n![\"Neuer](\"..\/fileadmin\/_temp_\/2026_04\/pic_1607_005.png\")
<\/p>\nZusammenfassung und Ausblick<\/h2>\n