<\/p>\n
Immer, wenn ich ein neues Add-In für eine Automatisierung meiner Access-Entwicklung erstelle, führe ich die gleichen Schritte durch: Anlegen einer neuen Datenbank, Speichern als .accda, Erstellen der Tabelle USysRegInfo, Hinzufügen der Daten für die Registry, Einstellen der Datenbankinformationen, sodass diese im Add-In-Manager angezeigt werden und Programmieren der Funktion, die beim Start des Add-Ins aufgerufen werden soll. Und erst danach fängt der eigentliche Spaß an, nämlich die Programmierung der Funktion, die ich gern mit dem Add-In erledigen möchte. Weil ich das oft genug gemacht habe, baue ich im Rahmen dieses Beitrags ein Tool, mit dem ich solche Add-Ins per Mausklick erstellen kann – beziehungsweise ein Add-In, mit dem ich die aktuelle Datenbank in ein Add-In umwandeln kann. <\/b><\/p>\n
Wenn ich schon regelmäßig Access-Add-Ins programmiere, um damit lästige, immer wieder auftretende Aufgaben zu vereinfachen – warum sollte ich dann nicht das Zusammenstellen der wichtigsten Elemente dieses Add-Ins auch automatisieren?<\/p>\n
Ich habe erst überlegt, mir eine Vorlage zu erstellen, die ich dann kopiere und anpasse. Aber letztlich sind doch einige Schritte zu erledigen.<\/p>\n
Selbst wenn die Tabelle USysRegInfo <\/b>in einer solchen Vorlage bereits vorhanden ist, muss ich die dortigen Daten noch einstellen, und auch die Informationen der Access-Datenbank selbst, die später im Add-In-Manager angezeigt werden, müssen immer wieder angepasst werden.<\/p>\n
Davon abgesehen schaffe ich es regelmäßig, die Daten in der Tabelle USysRegInfo <\/b>nicht korrekt einzugeben, und selbst der kleinste Fehler führt dazu, dass die Registrierung nicht durchgeführt wird oder das Access-Add-In anschließend dennoch nicht gestartet werden kann.<\/p>\n
Viel einfacher wäre es doch, wenn es ein Formular gäbe, das die wichtigsten Einstellungen vor dem Erstellen des Access-Add-Ins abfragt und diese automatisch anlegt.<\/p>\n
Nun stellt sich die Frage, wie wir das Erstellen eines neuen Access-Add-Ins gestalten wollen. Wir könnten beispielsweise eine herkömmliche Access-Datenbank erstellen, die ein Formular enthält, welches die Parameter für das Access-Add-In abfragt und diese dann auf die gleiche Datenbank anwendet.<\/p>\n
In dieser Datenbank könnten wir die Tabelle USysRegInfo <\/b>dann bereits vorbereiten und brauchen diese nur noch auf Basis der in das Formular eingegebenen Daten anzupassen – das gilt auch für die Datenbankinformationen.<\/p>\n
Die Alternative wäre, wiederum ein Access-Add-In zu programmieren, das der aktuell geöffneten Datenbank die notwendigen Elemente hinzufügt. Das Access-Add-In müsste dann die notwendigen Informationen abfragen, die Tabelle USysRegInfo<\/b> anlegen und mit den Daten für die Registrierung füllen, die Datenbankinformationen eintragen und das Modul mit der Funktion zum Starten des Access-Add-Ins anlegen.<\/p>\nMein Weg zu Access-Add-Ins<\/h2>\n
Ich gehe an dieser Stelle einmal von meiner eigenen Vorgehensweise beim Erstellen eines Access-Add-Ins aus. Diese sieht so aus, dass ich zu Beginn meist gar kein Access-Add-In plane, sondern einfach nur in irgendeiner Datenbankanwendung, die ich gerade programmiere, eine VBA-Prozedur hinzufüge, mit der ich eine Aufgabe automatisiere.<\/p>\n
Diese setze ich dann ein, stelle fest, dass sie gut funktioniert, und füge dann gegebenenfalls ein Formular hinzu, von dem ich die Prozedur aufrufe.<\/p>\n
Wenig später stelle ich dann fest, dass ich diese Funktion auch noch in weiteren Projekten nutzen könnte. Meistens kopiere ich diese dann zuerst in das betroffene Projekt und nutze es dort. Irgendwann kommt mir dann die Idee, dass ich ja auch ein Access-Add-In aus der Funktion machen könnte – und dann beginnen die Schritte, die ich bereits eingangs erwähnt habe.<\/p>\n
Ich starte also eher mit einer Datenbankanwendung, in der bereits die Funktionen des zukünftigen Access-Add-Ins enthalten sind und wandle diese dann in ein Add-In um. Dementsprechend legen wir die Lösung dieses Beitrags auch als Access-Add-In an – um damit über das Add-In-Menü die aktuell geöffnete Datenbank in ein Add-In umwandeln zu können.<\/p>\n
Bevor wir loslegen, benötigen wir ein Formular, mit dem der Benutzer die Daten eingeben kann, die für das Umrüsten des Add-Ins benötigt werden. Dieses Formular sieht in der Entwurfsansicht wie in Bild 1 aus. Wir verwenden hier die folgenden Textfelder:<\/p>\n
![\"Entwurf](\"..\/fileadmin\/_temp_\/2023_02\/pic_1427_001.png\")
<\/p>\n
Bild 1: Entwurf des Formulars zur Eingabe der Add-In-Daten<\/span><\/b><\/p>\n Damit gleich beim Öffnen des Formulars einige Beispieldaten erscheinen, füllen wir die Textfelder beim Laden des Formulars mit der folgenden Ereignisprozedur:<\/p>\n Dadurch sieht das Formular nach dem Öffnen wie in Bild 2 aus.<\/p>\n Bild 2: Das Formular zur Eingabe der Add-In-Daten in der Formularansicht<\/span><\/b><\/p>\n Damit wir die Access-Datenbank als Access-Add-In nutzen können, sind einige Schritte nötig, die im Code der Prozedur, die durch die Schaltfläche cmdZumAddInUmruesten <\/b>bereits skizziert sind (siehe Listing 1).<\/p>\n Listing 1: Code zum Umwandeln der aktuell geöffneten Datenbank in ein Access-Add-In<\/span><\/b><\/p>\n Die Prozedur deklariert und füllt zwei Database-Variablen: Die erste heißt db <\/b>und referenziert die aktuell geöffnete Datenbank (mit CurrentDb<\/b>), die zweite heißt dbc <\/b>und bezieht sich auf die Add-In-Datenbank (mit CodeDb<\/b>).<\/p>\n Bedenken Sie: Die Datenbank, die wir gerade programmieren, wird ja selbst ein Access-Add-In, mit dem wir die dann geladene Datenbank in ein Access-Add-In umwandeln wollen.<\/p>\n Die Prozedur ruft danach weitere Routinen auf. Die erste heißt CreateUSysRegInfo <\/b>und wird mit dem Verweis auf die aktuell geöffnete Datenbank als Parameter aufgerufen. Sie hat die Aufgabe, die Tabelle USysRegInfo <\/b>zu erstellen, welche die Informationen aufnimmt, die beim Installieren des Access-Add-Ins in die Registry geschrieben werden sollen, damit Access beim Öffnen auslesen kann, welche Access-Add-Ins verfügbar sind.<\/p>\n Diese Funktion prüft auch, ob die Tabelle USysRegInfo <\/b>bereits vorhanden ist – falls ja, wird der Vorgang abgebrochen.<\/p>\n Der Aufruf der Prozedur AddRegistryEntries <\/b>übergibt Verweise auf die aktuelle Datenbank, das aktuelle Access-Add-In, den Namen des zu erstellenden Add-Ins, den Wert 1 <\/b>als Parameter für den zu erstellenden Add-In-Typ (aktuell gibt es nur den einen), den Namen der beim Start aufzurufenden Funktion, die Beschreibung und den Dateinamen der zukünftigen Add-In-Datenbank. Sie soll die benötigten Daten in die Tabelle USysRegInfo <\/b>schreiben.<\/p>\n [<\/p>\n Die Prozedur ChangeProperties <\/b>soll die Eigenschaften der Datenbankdatei ändern, die später im Add-In-Manager angezeigt werden. Dazu erhält sie als Parameter den Verweis auf die zu ändernde Datenbank, den Namen des Add-Ins, die Beschreibung und den Hersteller.<\/p>\n Schließlich folgt noch die Prozedur AddStartfunction<\/b>, der wir den Verweis auf die Datenbank übergeben, welche um ein Modul mit dieser Funktion erweitert werden soll – und den Namen der anzulegenden Funktion.<\/p>\n Schließlich prüft die Prozedur noch, ob die Zieldatenbank bereits die Dateiendung .accda <\/b>hat und weist den Benutzer darauf hin, diesen gegebenenfalls anzupassen.<\/p>\n Die erste Funktion namens CreateUSysRegInfo <\/b>erwartet einen Verweis auf die in ein Access-Add-In umzuwandelnde Datenbank als Parameter (siehe Listing 2). Sie versucht zunächst, eine bereits bestehende Tabelle namens USysRegInfo <\/b>zu referenzieren. Gelingt dies, wird die Funktion mit dem Ergebnis False <\/b>abgebrochen, damit keine eventuell bereits angelegten Elemente überschrieben werden.<\/p>\n Listing 2: Code zum Erstellen der Tabelle USysRegInfo<\/span><\/b><\/p>\n Ist die Tabelle jedoch noch nicht vorhanden, legt die Prozedur diese mit der Methode CreateTableDef <\/b>des Database<\/b>-Objekts an und legt dabei direkt den Namen USysRegInfo <\/b>fest. Danach fügt sie durch mehrfaches Aufrufen der CreateField<\/b>-Methode des zuvor erstellten TableDef<\/b>-Objekts die Felder Subkey<\/b>, Type<\/b>, ValName <\/b>und Value <\/b>mit den entsprechenden Datentypen hinzu. Das Feld Type <\/b>wird dabei als Zahlenfeld definiert und alle anderen als Textfelder mit einer Länge von 255 Zeichen.<\/p>\n Jedes neue Field<\/b>-Objekt wird nach dem Erstellen mit der Append<\/b>-Methode an die Fields<\/b>-Auflistung des TableDef<\/b>-Objekts angehängt. Für das Feld Value <\/b>wird außerdem die Eigenschaft AllowZeroLength <\/b>auf True <\/b>eingestellt.<\/p>\n Schließlich hängt die Prozedur auch das neue TableDef<\/b>-Objekt an die TableDefs<\/b>-Auflistung des Database<\/b>-Objekts der aktuellen Datenbank an.<\/p>\n Die nächste Funktion namens AddRegistryEntries <\/b>übernimmt eine sehr wichtige Aufgabe, denn beim Anlegen der Einträge der Tabelle USysRegInfo<\/b> treten die meisten Fehler beim Erstellen von Access-Add-Ins auf (siehe Listing 3).<\/p>\n Listing 3: Code zum Füllen der Tabelle USysRegInfo<\/span><\/b><\/p>\n Sie erwartet als Parameter neben den Verweisen auf das aktuelle und das zukünftige Add-In den Namen des Add-Ins, die ID des zu verwendenden Templates (hier gibt es aktuell nur den Wert 1 <\/b>für das Menü-Add-In), die aufzurufende Funktion, die Beschreibung und den Dateinamen (mit der Dateiendung .accda<\/b>).<\/p>\n Die Funktion öffnet ein Recordset auf Basis der soeben angelegten Tabelle USysRegInfo <\/b>in der Zieldatenbank. Außerdem erstellt sie ein Recordset, das die Daten der Tabelle tblRegistryEntries <\/b>des Add-In-Creators für das verwendete Template enthält.<\/p>\n Diese Tabelle enthält im aktuellen Zustand nur die Basisdaten für das Anlegen von Menü-Add-Ins (siehe Bild 3).<\/p>\n Bild 3: Tabelle mit den Basisdaten zum Füllen der neuen USysRegInfo-Tabelle<\/span><\/b><\/p>\n Die Funktion durchläuft anschließend alle Datensätze dieser Tabelle für die übergebene TemplateID und schreibt den Wert des Feldes RegistryValue <\/b>in die Variable strValue<\/b>. Für diese ersetzt sie die Platzhalter [Expression]<\/b>, [Description] <\/b>und [Filename] <\/b>durch die jeweiligen mit strExpression<\/b>, strDescription <\/b>und strFilename <\/b>gelieferten Werte.<\/p>\n Dann legt sie für den aktuellen Datensatz der Tabelle tblRegistryEntries <\/b>einen neuen Datensatz in der Tabelle USysRegInfo <\/b>an und trägt die Werte für die Felder Subkey<\/b>, Type<\/b>, ValName <\/b>und Value <\/b>ein.<\/p>\n Das Ergebnis für die Beispieldaten aus dem Screenshot von oben finden Sie in Bild 4.<\/p>\n Bild 4: Frisch gefüllte USysRegInfo-Tabelle<\/span><\/b><\/p>\n Die Prozedur ChangeProperties <\/b>erwartet einen Verweis auf die zukünftige Add-In-Datenbank, den Namen des Add-Ins, die Beschreibung und die Firma als Parameter (siehe Listing 4). Sie soll die Datenbankeigenschaften ändern, die wir sehen, wenn wir im Ribbon auf Datei|Informationen <\/b>und dann auf Datenbankeigenschaften anzeigen und bearbeiten <\/b>klicken.<\/p>\n Listing 4: Code zum Anlegen und Füllen von Datenbank-Eigenschaften<\/span><\/b><\/p>\n Um diese Eigenschaften zu ändern, müssen wir mit Container<\/b>-, Document<\/b>– und Property<\/b>-Eigenschaften arbeiten. Deshalb referenziert die Prozedur zuerst das Container<\/b>-Objekt Databases <\/b>des zukünftigen Access-Add-Ins und dann das darin enthaltene Document<\/b>-Objekt SummaryInfo<\/b>. Hier versuchen wir nacheinander, bei deaktivierter Fehlerbehandlung die Eigenschaften Title<\/b>, Company <\/b>und Comments <\/b>anzulegen und zu füllen. Den Fehler, der bei bereits vorhandenen Properties ausgelöst wird, ignorieren wir so und füllen sicherheitshalber anschließend nochmals die Properties mit den Werten aus den jeweiligen Parametern.<\/p>\n Das Ergebnis sieht anschließend wie in Bild 5 aus.<\/p>\n Bild 5: Automatisch gefüllte Datenbankeigenschaften<\/span><\/b><\/p>\n Damit fehlt noch das Hinzufügen der VBA-Funktion, die beim Starten des Access-Add-Ins ausgelöst werden soll und die wir bereits in die Tabelle USysRegInfo <\/b>eingetragen haben. Diese Aufgabe übernimmt die Funktion AddStartfunction<\/b>, die eine Verweis auf die zukünftige Add-In-Datenbank erwartet sowie den Namen der anzulegenden Funktion (siehe Listing 5).<\/p>\n Listing 5: Code zum Hinzufügen der Startfunktion des Access-Add-Ins<\/span><\/b><\/p>\n Sie stellt den Pfad für eine Textdatei zusammen, die im gleichen Verzeichnis wie die aktuell bearbeitete Datenbank liegt und den Namen mdlAddIn.bas <\/b>erhält.<\/p>\n Sollte diese Datei bereits vorhanden sein, wird sie zuvor gelöscht. Dann stellt die Prozedur in der Variablen strCode <\/b>den Inhalt des zu erstellenden Moduls zusammen. Dabei fügt sie den Namen der Funktion an die entsprechende Stelle im Code ein.<\/p>\n Den vollständigen Inhalt des Moduls speichert die Prozedur anschließend in der Datei aus strModulePath<\/b>.<\/p>\n Schließlich liest sie diese Datei mit der LoadFromText<\/b>-Methode als neues Modul in die aktuelle Datenbank ein.<\/p>\n Damit sind die Arbeiten abgeschlossen – der letzte Schritt ist gegebenenfalls das Umbenennen des Datenbanknamens, sodass die Dateiendung .accda <\/b>lautet. Der Teil vor der Dateiendung sollte nun allerdings nicht mehr geändert werden, da sonst die Einträge in der Tabelle USysRegInfo <\/b>nicht mehr passen.<\/p>\n Bevor wir mit dem Add-In andere Add-Ins erstellen können, müssen wir es jedoch erst noch als Add-In installieren. Der Vorteil ist: Das Add-In hat alle Werkzeuge an Bord, um sich selbst in ein Access-Add-In umzurüsten. Dazu rufen wir das Formular frmAddInCreator <\/b>auf und füllen die Felder wie in Bild 6.<\/p>\n Bild 6: Umrüsten des Add-In-Creators zu einem Add-In<\/span><\/b><\/p>\n Dann klicken wir auf die Schaltfläche Zum Add-In umrüsten<\/b>. Im Navigationsbereich sollten die Tabelle USysRegInfo <\/b>und das Modul mdlAddIn <\/b>erscheinen (die Tabelle ist nur sichtbar, wenn die Anzeige von Systemobjekten aktiviert ist). Wenn die Datenbank bereits die richtige Dateiendung hat, können wir diese nun schließen, eine beliebige andere Datenbank öffnen und dort den Add-In-Manager aktivieren.<\/p>\n Zuvor müssen wir allerdings noch die Funktion Autostart <\/b>anpassen. Diese zeigt aktuell noch ein Meldungsfenster an, aber wir wollen das Formular frmAddInCreator <\/b>öffnen. Deshalb gestalten wir die Funktion wie folgt:<\/p>\n Um das frisch erstellte Access-Add-In zu testen, müssen wir es noch als Add-In installieren.<\/p>\n Dazu öffnen wir eine beliebige Access-Datenbank und rufen dann den Ribbonbefehl Datenbanktools|Add-Ins|Add-Ins|Add-In-Manager <\/b>auf (siehe Bild 7). Dort klicken wir auf Neues hinzufügen… <\/b>und wählen unsere Add-In-Creator-Datenbank aus.<\/p>\n\n
Private Sub <\/span>Form_Load()\r\n Me!txtAddInName = \"Add-In-Name\"\r\n Me!txtBeschreibung = _\r\n \"Dies ist die Beschreibung des Add-Ins.\"\r\n Me!txtHersteller = \"Hersteller\"\r\n Me!txtStartfunktion = \"Autostart\"\r\n Me!txtAddInDatei = _\r\n Replace<\/span>(CurrentProject.Name, \".accdb\", \".accda\")\r\nEnd Sub<\/span><\/pre>\n![\"Das](\"..\/fileadmin\/_temp_\/2023_02\/pic_1427_002.png\")
<\/p>\nUmwandeln der Access-Datenbank in ein Access-Add-In<\/h2>\n
Private Sub <\/span>cmdZumAddInUmruesten_Click()\r\n Dim <\/span>db As <\/span>dao.Database\r\n Dim <\/span>dbc As <\/span>dao.Database\r\n Set<\/span> db = CurrentDb\r\n Set<\/span> dbc = CodeDb\r\n If <\/span>Not<\/span> CreateUSysRegInfo(db) Then<\/span>\r\n MsgBox<\/span> \"Offensichtlich ist bereits eine Tabelle namens ''USysRegInfo'' vorhanden.\" & vbCrLf<\/span> _\r\n & \"Prüfen Sie die aktuelle Datenbank.\" & vbCrLf<\/span> & vbCrLf<\/span> _\r\n & \"Der Vorgang wird abgebrochen.\", vbOKOnly + vbExclamation\r\n Exit Sub<\/span>\r\n End If<\/span>\r\n AddRegistryEntries db, dbc, Me!txtAddInName, 1, Me!txtStartfunktion, Me!txtBeschreibung, Me!txtAddInDatei\r\n ChangeProperties db, Me!txtAddInName, Me!txtBeschreibung, Me!txtHersteller\r\n AddStartfunction db, Me!txtStartfunktion\r\n If <\/span>Not<\/span> Right<\/span>(CurrentProject.Name, 6) = \".accda\" Then<\/span>\r\n MsgBox<\/span> \"Die Dateiendung muss noch in .accda geändert werden.\", vbOKOnly + vbExclamation, \"Dateiendung anpassen\"\r\n End If<\/span>\r\nEnd Sub<\/span><\/pre>\nErstellen der Tabelle USysRegInfo<\/h2>\n
Public Function <\/span>CreateUSysRegInfo(dbAddIn As <\/span>dao.Database) As Boolean<\/span>\r\n Dim <\/span>tdf As <\/span>dao.TableDef\r\n Dim <\/span>fld As <\/span>dao.Field\r\n On Error Resume Next<\/span>\r\n Set<\/span> tdf = dbAddIn.TableDefs(\"USysRegInfo\")\r\n If <\/span>Not<\/span> tdf Is Nothing Then<\/span>\r\n Exit Function<\/span>\r\n End If<\/span>\r\n On Error GoTo<\/span> 0\r\n Set<\/span> tdf = dbAddIn.CreateTableDef(\"USysRegInfo\")\r\n With<\/span> tdf\r\n Set<\/span> fld = .CreateField(\"Subkey\", dbText, 255)\r\n tdf.Fields.Append fld\r\n Set<\/span> fld = .CreateField(\"Type\", dbInteger)\r\n tdf.Fields.Append fld\r\n Set<\/span> fld = .CreateField(\"ValName\", dbText, 255)\r\n tdf.Fields.Append fld\r\n Set<\/span> fld = .CreateField(\"Value\", dbText, 255)\r\n fld.AllowZeroLength = True<\/span>\r\n tdf.Fields.Append fld\r\n dbAddIn.TableDefs.Append tdf\r\n End With<\/span>\r\n CreateUSysRegInfo = True<\/span>\r\nEnd Function<\/span><\/pre>\nAnlegen der Tabelleneinträge für die Registrierung<\/h2>\n
Public Function <\/span>AddRegistryEntries(dbAddIn As <\/span>dao.Database, dbTemplate As <\/span>dao.Database, strAddInName As String<\/span>, _\r\n lngTemplateID As Long<\/span>, strExpression As String<\/span>, strDescription As String<\/span>, strFilename As String<\/span>)\r\n Dim <\/span>rstTemplate As <\/span>dao.Recordset\r\n Dim <\/span>rstAddIn As <\/span>dao.Recordset\r\n Dim <\/span>strValue As String<\/span>\r\n Set<\/span> rstAddIn = dbAddIn.OpenRecordset(\"USysRegInfo\", dbOpenDynaset)\r\n Set<\/span> rstTemplate = dbTemplate.OpenRecordset(\"SELECT * FROM tblRegistryEntries WHERE TemplateID = \" _\r\n & lngTemplateID, dbOpenDynaset)\r\n Do While<\/span> Not<\/span> rstTemplate.EOF\r\n strValue = Nz(rstTemplate!RegistryValue)\r\n strValue = Replace<\/span>(strValue, \"[Expression]\", strExpression)\r\n strValue = Replace<\/span>(strValue, \"[Description]\", strDescription)\r\n strValue = Replace<\/span>(strValue, \"[Filename]\", strFilename)\r\n rstAddIn.AddNew<\/span>\r\n rstAddIn!Subkey = rstTemplate!RegistrySubkey & strAddInName\r\n rstAddIn!Type = rstTemplate!RegistryEntryType\r\n rstAddIn!ValName = rstTemplate!RegistryValname\r\n rstAddIn!Value = strValue\r\n rstAddIn.Update\r\n rstTemplate.MoveNext<\/span>\r\n Loop<\/span>\r\nEnd Function<\/span><\/pre>\n![\"Tabelle](\"..\/fileadmin\/_temp_\/2023_02\/pic_1427_003.png\")
<\/p>\n![\"Frisch](\"..\/fileadmin\/_temp_\/2023_02\/pic_1427_004.png\")
<\/p>\nAnlegen und Schreiben der Datenbankeigenschaften<\/h2>\n
Public Sub <\/span>ChangeProperties(dbAddIn As <\/span>dao.Database, strAddInName As String<\/span>, strDescription As String<\/span>, _\r\n strCompany As String<\/span>)\r\n Dim <\/span>con As <\/span>dao.Container\r\n Dim <\/span>doc As <\/span>dao.Document\r\n Dim <\/span>prp As <\/span>dao.Property\r\n Set<\/span> con = dbAddIn.Containers(\"Databases\")\r\n Set<\/span> doc = con.Documents(\"SummaryInfo\")\r\n On Error Resume Next<\/span>\r\n Set<\/span> prp = doc.CreateProperty(\"Title\", dbText, strAddInName)\r\n doc.Properties.Append prp\r\n If <\/span>Not<\/span> Err.Number = 0 Then<\/span>\r\n doc.Properties(\"Title\") = strAddInName\r\n End If<\/span>\r\n On Error GoTo<\/span> 0\r\n On Error Resume Next<\/span>\r\n Set<\/span> prp = doc.CreateProperty(\"Company\", dbText, strCompany)\r\n doc.Properties.Append prp\r\n If <\/span>Not<\/span> Err.Number = 0 Then<\/span>\r\n doc.Properties(\"Company\") = strCompany\r\n End If<\/span>\r\n On Error GoTo<\/span> 0\r\n On Error Resume Next<\/span>\r\n Set<\/span> prp = doc.CreateProperty(\"Comments\", dbText, strDescription)\r\n doc.Properties.Append prp\r\n If <\/span>Not<\/span> Err.Number = 0 Then<\/span>\r\n doc.Properties(\"Comments\") = strDescription\r\n End If<\/span>\r\n On Error GoTo<\/span> 0\r\nEnd Sub<\/span><\/pre>\n![\"Automatisch](\"..\/fileadmin\/_temp_\/2023_02\/pic_1427_005.png\")
<\/p>\nHinzufügen eines Moduls mit der Startfunktion<\/h2>\n
Public Sub <\/span>AddStartfunction(dbAddIn As <\/span>dao.Database, strFunction As String<\/span>)\r\n Dim <\/span>strCode As String<\/span>\r\n Dim <\/span>strModulePath As String<\/span>\r\n strModulePath = CurrentProject.Path & \"\\mdlAddIn.bas\"\r\n On Error Resume Next<\/span>\r\n Kill strModulePath\r\n On Error GoTo<\/span> 0\r\n strCode = \"Option Explicit\" & vbCrLf<\/span>\r\n strCode = strCode & \"Option Compare Database\" & vbCrLf<\/span> & vbCrLf<\/span>\r\n strCode = strCode & \"Public Function \" & strFunction & \"()\" & vbCrLf<\/span>\r\n strCode = strCode & \" Msgbox \"\"Beispiel-Add-In\"\"\" & vbCrLf<\/span>\r\n strCode = strCode & \"End Function\"\r\n Open strModulePath For Append As <\/span>#1\r\n Print #1, strCode\r\n Close #1\r\n LoadFromText acModule, \"mdlAddIn\", strModulePath\r\nEnd Sub<\/span><\/pre>\nAdd-In-Creator als Add-In installieren<\/h2>\n
![\"Umrüsten](\"..\/fileadmin\/_temp_\/2023_02\/pic_1427_006.png\")
<\/p>\nPublic Function <\/span>Autostart()\r\n DoCmd.OpenForm \"frmAddInCreator\"\r\nEnd Function<\/span><\/pre>\nAusprobieren des so erstellten Access-Add-Ins<\/h2>\n
![\"Installieren](\"..\/fileadmin\/_temp_\/2023_02\/pic_1427_007.png\")
<\/p>\n
![\"Das](\"..\/fileadmin\/_temp_\/2023_02\/pic_1427_008.png\")
<\/p>\n