<\/p>\n
Bevor man umfangreichere Änderungen an bestehenden Anwendungen vornimmt, sollte man zumindest eine Sicherungskopie der Datenbankdatei machen. Außen vor sind hier Entwickler, die den Code ihrer Anwendungen mit einer Quellcodeverwaltung tracken – hier kann man den Verlauf der Änderungen leicht nachvollziehen. Wer aber den Aufwand nicht betreiben will, kann auch mit einfacheren Mitteln prüfen, welche Änderungen seit dem letzten Speichern durchgeführt wurden – und zwar mit der in diesem Beitrag vorgestellten Lösung. Hier bauen wir auf einer einfachen Funktion auf, die den kompletten Inhalt aller VBA-Module exportiert und schauen uns dann die Unterschiede mit einem Texteditor an.<\/b><\/p>\n
VBE zugreifbar machen<\/b><\/p>\n
Wenn wir auf den Inhalt des VBA-Projekts einer Anwendung zugreifen wollen, benötigen wir die Bibliothek mit den Befehlen für den Zugriff auf das VBE-Objekt. Dieses bietet alle notwendigen Objekte, Eigenschaften und Methoden, um auf die Module und ihre Inhalte zuzugreifen. Die Bibliothek machen wir verfügbar, indem wir einen Verweis darauf zum aktuellen Projekt hinzufügen.<\/p>\n
Dazu öffnen Sie den VBA-Editor (von Access beispielsweise mit Alt + F11<\/b>) und starten dann den Verweise<\/b>-Dialog mit dem Menübefehl Extras|Verweise<\/b>. Hier aktivieren Sie den Eintrag Microsoft Visual Basic for Applications Extensibility 5.3 Object Library <\/b>(siehe Bild 1).<\/p>\n
![\"Verweis](\"..\/fileadmin\/_temp_\/2020_04\/pic_1248_001.png\")
<\/p>\n
Bild 1: Verweis auf die Bibliothek Microsoft Visual Basic for Applications Extensibility 5.3 Object Library<\/span><\/b><\/p>\n Damit können wir mit einer recht einfachen Prozedur alle VBA-Module durchlaufen, diese in einer String-Variablen zusammenfassen und sie dann in einer Textdatei speichern, um sie mit einem Export aus einer anderen Datenbank zu vergleichen.<\/p>\n VBA-Code komplett exportieren<\/b><\/p>\n Die folgende Prozedur exportiert den kompletten Code eines VBA-Projekts in eine Textdatei. Sie deklariert Variablen zum Referenzieren des VBA-Editors (objVBE<\/b>), des aktuellen VBA-Projekts (objVBProject<\/b>), einer VBA-Komponente (objVBComponent<\/b>) und des darin enthaltenen Code-Moduls (objCodeModule<\/b>).<\/p>\n Außerdem benötigen wir noch Variablen zum Zusammenfügen des Codes der Elemente und für den Dateinamen:<\/p>\n Damit referenziert die Prozedur den VBA-Editor und ermittelt mit der Eigenschaft ActiveVBProject <\/b>das aktuell geöffnete VBA-Projekt:<\/p>\n Dann durchläuft sie alle VBComponent<\/b>-Elemente, also alle Standardmodule, Klassenmodule und Formular- und Berichtsmodule aus der Auflistung VBComponents <\/b>in einer For Each<\/b>-Schleife und referenziert diese mit der Variablen objVBComponent<\/b>:<\/p>\n In der Schleife referenziert die Prozedur das im VBComponent<\/b>-Element enthaltene Code-Modul mit der Variablen obj-CodeModule <\/b>und fügt dieses mit einer führenden und einer nachfolgenden Zeile zur optischen Hervorhebung zusammen:<\/p>\n Danach folgt der eigentliche Inhalt des VBA-Moduls, der mit der Lines<\/b>-Eigenschaft für alle Zeilen von der ersten bis zu der mit CountOfLines <\/b>ermittelten letzten Zeile ermittelt wird:<\/p>\n Nachdem auf diese Weise alle Module in der Variablen strVBA <\/b>zusammengestellt wurden, schreibt die Prozedur deren Inhalt in eine Textdatei, die den Namen der Datenbank plus die Endung .vba.txt <\/b>enthält:<\/p>\n Diesen Vorgang führen Sie nun mit der aktuellen und mit der zu vergleichenden Version des VBA-Projekts durch und speichern auch diese Datei.<\/p>\n Vergleichen der beiden Dateien<\/b><\/p>\n Zum Vergleichen gibt es zahlreiche Anwendungen. Wir arbeiten seit Ewigkeiten mit TextPad, welches eine Funktion zum Vergleichen des Inhalts zweier Dateien anbietet.<\/p>\n Die umständliche Vorgehensweise hier lautet:<\/p>\n TextPad zeigt dann den Dialog Textdateien vergleichen<\/b> an, der die beiden aktuell geöffneten Dateien als erste und zweite zu vergleichende Datei anbietet (siehe Bild 2) – Sie brauchen also nur noch auf OK<\/b> zu klicken.<\/p>\n Bild 2: Optionen für das Vergleichen von Textdateien<\/span><\/b><\/p>\n Danach zeigt Textpad die Unterschiede entsprechend hervorgehoben an (siehe Bild 3).<\/p>\n Bild 3: Vergleich des Inhalts zweier VBA-Projekte im Text-Editor TextPad<\/span><\/b><\/p>\n TextPad direkt mit Dateien öffnen<\/b><\/p>\n TextPad bietet einige Startparameter an, mit denen wir unter anderem direkt eine oder mehrere Dateien angeben können, die beim Start geöffnet werden sollen. Dazu nutzen wir unter VBA die Shell<\/b>-Funktion und geben hinter dem Pfad zur TextPad.exe <\/b>die Namen der zu öffnenden Dateien an – zur Sicherheit in Anführungszeichen eingeschlossen, falls die Dateinamen Leerzeichen enthalten:<\/p>\n Danach brauchen Sie nur noch den Menüeintrag Extras|Dateien vergleichen… <\/b>aufzurufen.<\/p>\n Add-In-Unterstützung<\/b><\/p>\n Da die Vorgehensweise immer noch ein wenig kompliziert ist – immerhin müssen wir die Prozedur CodeKomplettExportieren <\/b>in jede betroffene Datenbank kopieren, immer beide Datenbanken öffnen, um den VBA-Code zu exportieren und diese dann wieder schließen -, behelfen wir uns mit einem kleinen, aber effizienten Access-Add-In.<\/p>\n Dieses legen wir in Form einer neuen, leeren Access-Datenbank an, deren Name wir noch vor der ersten Änderung in amvVBAVergleich.accda<\/b> umbenennen (.accda <\/b>ist die Dateiendung, unter der Access-Add-Ins erkannt werden).<\/p>\n USysRegInfo-Tabelle<\/b><\/p>\n Damit die Datenbank als Add-In registriert werden kann, fügen wir ihr eine Tabelle namens USysRegInfo <\/b>hinzu, welche die Informatoinen enthält, die beim Installieren des Add-Ins in der Registry gespeichert werden. Von dort liest Access diese Informationen beim Start aus und zeigt das Add-In an der entsprechenden Stelle an – meist im Ribbon-Menü Datenbanktools|Add-Ins|Add-Ins<\/b>.<\/p>\n Diese Tabelle sieht wie in Bild 4 aus und muss genau die dort abgebildeten Informationen enthalten – zumindest jedoch muss der Wert in Subkey <\/b>übereinstimmen und der im vierten Datensatz angegebene Dateiname im Feld Value <\/b>muss mit dem Dateinamen der Add-In-Datenbank übereinstimmen.<\/p>\n Bild 4: Add-In-Einstellungen in der Tabelle USysRegInfo<\/span><\/b><\/p>\n Datenbank-informationen<\/b><\/p>\n Damit das Add-In später im Add-In-Manager ordentlich angezeigt wird, stellen wir außerdem noch Werte im Eigenschaften-Fenster von Access ein. Dieses öffnen Sie in aktuellen Versionen von Access unter Datei|Informationen <\/b>mit dem Link Datenbankeigenschaften anzeigen und bearbeiten<\/b>. Hier legen Sie die Werte wie in Bild 5 fest.<\/p>\n <\/p>\n Bild 5: Datenbank-Eigenschaften<\/span><\/b><\/p>\n Autostart-Funktion<\/b><\/p>\n Damit beim Aufrufen des Add-Ins etwas geschieht, fügen Sie einem Standardmodul der Add-In-Datenbank eine öffentliche Funktion namens Autostart <\/b>hinzu (dass diese Funktion so heißt, haben wir in der Tabelle USysRegInfo <\/b>festgelegt). Diese Funktion soll ein Formular namens frmVBAVergleich <\/b>öffnen.<\/p>\n Das Formular frmVBAVergleich<\/b><\/p>\n Dieses Formular legen wir als Nächstes an. Da dieses Formular keine Möglichkeit zum Navigieren in Datensätzen anzeigen soll, stellen wir die Eigenschaften Datensatzmarkierer<\/b>, Navigationsschaltflächen <\/b>und Bildlaufleisten <\/b>auf Nein <\/b>ein und die Eigenschaft Automatisch zentrieren <\/b>auf Ja<\/b>.<\/p>\n Es soll aber dennoch an eine Datenherkunft gebunden werden, nämlich an die Tabelle tblOptionen<\/b>. Diese soll den Namen des aufzurufenden Tools für den Vergleich der VBA-Projekte speichern sowie die Konstellation der Platzhalter für die Namen der zu vergleichenden Dateien, falls diese per Startparameter übergeben werden können. Diese Tabelle sieht in der Entwurfsansicht wie in Bild 6 aus.<\/p>\n Bild 6: Optionen-Tabelle der Anwendung<\/span><\/b><\/p>\n Das Formular binden wir über die Eigenschaft Datensatzquelle <\/b>an die Tabelle tblOptionen<\/b>. Damit es nur den einzigen Datensatz der Tabelle tblOptionen <\/b>anzeigen kann, stellen wir die Eigenschaft Zyklus <\/b>des Formulars auf Aktueller Datensatz <\/b>ein.<\/p>\n Der Entwurf des Formulars soll wie in Bild 7 aussehen. Die oberen beiden Textfelder txtDatenbank1 <\/b>und txtDatenbank2 <\/b>sind ungebundene Felder, in welche der Benutzer die Pfade zu den Datenbanken mit den zu vergleichenden VBA-Projekten einlesen kann.<\/p>\n Bild 7: Das Formular zum Starten des Vergleichs zweier VBA-Projekte<\/span><\/b><\/p>\n Dies geschieht über die beiden Schaltflächen cmdDatenbank1Auswaehlen <\/b>und cmdDatenbank2Auswaehlen<\/b>. Das Tool zur Anzeige der Unterschiede kann auf ähnliche Weise ausgewählt werden, und zwar über die Schaltfläche cmdToolAuswaehlen<\/b>.<\/p>\n Schließlich kann der Benutzer noch Platzhalter in das Textfeld txtParameter <\/b>eintragen. Es stehen die beiden Parameter [Datenbank1] <\/b>und [Datenbank2] <\/b>zur Verfügung. [Datenbank1] <\/b>wird durch den Pfad aus dem Textfeld txtDatenbank1 <\/b>ersetzt und [Datenbank2] <\/b>durch den Pfad aus txtDatenbank2<\/b>.<\/p>\n Erste\/zweite Datenbank auswählen<\/b><\/p>\n Die Prozedur zum Auswählen der ersten Datenbank, die durch einen Klick auf die Schaltfläche cmdDatenbank1Auswaehlen <\/b>ausgelöst wird, kann zum Auswählen einer oder beider zu vergleichender Datenbankdateien genutzt werden (siehe Listing 1). Letzteres ist nur möglich, wenn sich beide Dateien im gleichen Verzeichnis befinden.<\/p>\n Die Prozedur öffnet mit der Funktion OpenFileNameMultiple <\/b>einen Dateiauswahl-Dialog und übergibt diesem das aktuelle Datenbankverzeichnis als Startverzeichnis sowie die möglichen Dateiendungen *.mdb <\/b>und *.accdb<\/b>. Diese können Sie nach Belieben erweitern.<\/p>\n Die Funktion öffnet den Dateiauswahl-Dialog so, dass mehr als eine Datei gleichzeitig geöffnet werden kann (siehe Bild 8).<\/p>\n Bild 8: Auswahl zweier Datenbanken gleichzeitig<\/span><\/b><\/p>\n Nach der Auswahl der Dateien über den Dateiauswahl-Dialog wertet die Prozedur cmdDatenbank1Auswaehlen_Click <\/b>das Ergebnis aus. Wenn mehr als eine Datei ausgewählt wurde, werden die einzelnen Pfade durch das Tabulator-Zeichen getrennt zurückgeliefert. Daher trennt die Prozedur das Ergebnis mit der Split<\/b>-Funktion jeweils am Tabulator-Zeichen und schreibt die einzelnen Pfade in das String<\/b>-Array strFiles<\/b>.<\/p>\n Die nächste If…Then<\/b>-Bedingung prüft anhand der Differenz aus dem größten und dem kleinsten Index der Array-Elemente, ob mehr als ein Pfad ausgewählt wurde. Ist das der Fall, weist die Prozedur mit einem Meldungsfenster darauf hin.<\/p>\n Dann durchläuft die Prozedur alle Elemente des Arrays und weist den Pfad aus dem ersten Element dem ersten Textfeld zu und den aus dem zweiten Element dem zweiten Textfeld. Hat der Benutzer mehr als zwei Datenbanken ausgewählt, werden die übrigen Elemente ignoriert, indem die Schleife verlassen wird.<\/p>\n Schließlich ruft die Prozedur noch eine weitere Routine namens SchaltflaecheAktivieren <\/b>auf. Diese Prozedur, die wir weiter unten erläutern, soll prüfen, ob für die drei Textfelder mit Dateipfaden gültige Pfade ausgewählt wurden und nur dann die Schaltfläche cmdVergleichStarten <\/b>aktivieren.<\/p>\n Damit diese beim Starten des Add-Ins nicht aktiviert ist, stellen wir ihre Eigenschaft Aktiviert <\/b>auf Nein <\/b>ein.<\/p>\n Zweite Datei auswählen<\/b><\/p>\n Die Schaltfläche cmdDatenbank2Auswaehlen<\/b> löst die Ereignisprozedur aus Listing 2 aus. Diese verwendet nicht die Funktion OpenFileNameMultiple<\/b>, sondern die Funktion OpenFileName<\/b>. Diese erlaubt lediglich die Auswahl einer einzigen Datei.<\/p>\n Dementsprechend fällt auch die Auswertung des Ergebnisses etwas kürzer aus. Hier lesen wir einfach nur den Rückgabewert in die Variable strFile <\/b>ein und schreiben diese in das Textfeld txtDatenbank2<\/b>. Außerdem rufen wir auch hier die Routine SchaltflaechenAktivieren <\/b>auf.<\/p>\n Tool zum Vergleichen auswählen<\/b><\/p>\n Eine fast identisch aufgebaute Prozedur verwenden wir, wenn der Benutzer die Schaltfläche cmdToolAuswaehlen <\/b>anklickt. Hier verwenden wir lediglich einen anderen Filter für die Dateiendung, nämlich *.exe<\/b>. Das Ergebnis landet im Textfeld txtTool<\/b>, das an das Feld Tool <\/b>der Tabelle tblOptionen <\/b>gebunden ist und dessen Wert folglich beim nächsten Start wiederhergestellt wird:<\/p>\n Manuelle Eingabe von Dateien<\/b><\/p>\n Es kann auch passieren, dass der Benutzer den Pfad zu den Datenbanken mit den zu vergleichenden VBA-Projekten manuell in die Textfelder eingibt. Das ist kein Problem, wir müssen allerdings auch in diesem Fall prüfen, ob alle eingegebenen Pfade gültig und vorhanden sind. Also legen wir für die drei Textfelder Ereignisprozeduren <\/b>an, die durch das Ereignis Bei Änderungen <\/b>ausgelöst werden.<\/p>\n Diese drei Prozeduren sehen wie folgt aus:<\/p>\n Wichtig ist hier, dass die Prozedur für das auslösende Textfeld nicht den Wert des Textfeldes, sondern den aktuellen Text als Parameter an die Prozedur SchaltflaecheAktivieren <\/b>übergibt.<\/p>\n Wenn der Benutzer Änderungen vornimmt und damit das Ereignis Bei Änderung <\/b>auslöst, wird der Wert des Textfeldes nämlich noch nicht geändert, sondern nur der Wert der Eigenschaft Text<\/b>. Und man kann nicht einfach den Wert der Eigenschaft Text <\/b>für alle betroffenen Steuer-elemente übergeben, sondern nur für das, welches aktuell den Fokus hat – sonst löst man einen Fehler aus.<\/p>\n Schaltfläche aktivieren oder deaktivieren<\/b><\/p>\n Die bereits mehrfach erwähnte Schaltfläche cmdVergleichStarten <\/b>soll erst aktiviert werden, wenn die drei Textfelder txtDatenbank1<\/b>, txtDatenbank2 <\/b>und txtTool <\/b>Pfade zu gültigen und vorhandenen Dateien aufweisen.<\/p>\n Dazu nimmt die folgende Prozedur die Inhalte der drei Textfelder entgegen und prüft nacheinander, ob die Dir-Funktion für den Pfad einen Dateinamen zurückliefert. Ist das bei allen drei übergebenen Parametern der Fall, wird die Variable bolAktiviert <\/b>auf True <\/b>eingestellt. Dieser Wert wird dann der Eigenschaft Enabled <\/b>der Schaltfläche cmdVergleichStarten <\/b>zugewiesen:<\/p>\n Vergleich starten<\/b><\/p>\n Ein Klick auf die Schaltfläche aus Bild 9 startet den Vergleich der enthaltenen VBA-Projekte. Hier rufen wir für die beiden Dateien aus den Textfeldern txtDatenbank1 <\/b>und txtDatenbank2 <\/b>jeweils die Funktion CodeKomplettExportieren <\/b>auf und übergeben den Pfad zur Datenbank sowie den Wert 1 <\/b>oder 2<\/b> – je nach der Datenbank, für die wir die Funktion aufrufen.<\/p>\n Bild 9: Starten des Vergleichs<\/span><\/b><\/p>\n Diese Funktion, die wir weiter unten beschreiben, speichert den Inhalt der VBA-Projekte im Verzeichnis der Add-In-Datenbank.<\/p>\n Danach fasst die Prozedur cmdVergleichStarten_Click <\/b>zunächst den Pfad zu dem Tool aus txtTool <\/b>in Anführungszeichen ein. Dann verarbeitet sie den Eintrag des Textfeldes txtParameter<\/b>.<\/p>\n Dort kann man beliebige Parameter für den Aufruf des Vergleichstools organisieren und dabei die beiden Platzhalter [Datenbank1] <\/b>und [Datenbank2] <\/b>verwenden, die durch die Pfade der zu vergleichenden Datenbankdateien ersetzt werden.<\/p>\n Schließlich fügt die Prozedur die Parameter an strBefehl <\/b>an und ruft strBefehl <\/b>mit der Shell<\/b>-Funktion auf.<\/p>\n VBA-Projekte exportieren<\/b><\/p>\n Die eingangs vorgestellte Prozedur, mit der wie die VBA-Projekte exportiert haben, müssen wir anpassen. Die Funktion nimmt den Namen der Datenbank, deren VBA-Projekt exportiert werden soll, sowie die Nummer der zu exportierenden Datei entgegen. Letztere wird im Dateinamen der zu erzeugenden Datei verwendet.<\/p>\n Warum aber müssen wir die Prozedur vom Beginn des Artikels überhaupt ändern Weil wir hier nicht mehr nur einfach das VBA-Projekt der aktuellen Datenbank exportieren wollen, sondern in der Regel das VBA-Projekt der aktuell geöffneten Datenbank und das VBA-Projekt der zu vergleichenden Datenbank.<\/p>\n Vielleicht möchte der Benutzer sogar zwei Datenbanken vergleichen, die nicht gleich der aktuell geöffneten Datenbank sind.<\/p>\n Deshalb referenziert die Funktion aus Listing 4 zunächst den VBA-Editor.<\/p>\n Um das zu vergleichende VBA-Projekt zu referenzieren, wollen wir einen Verweis auf dieses Projekt hinzufügen. Dann können wir mit den Methoden des VBE<\/b>-Objekts auf seine Inhalte zugreifen, ohne das wir die Datenbank per Code öffnen müssen.<\/p>\n Dazu benötigen wir als Erstes einen Verweis auf das VBA-Projekt des Add-Ins. Diesen holen wir uns in einer For Each<\/b>-Schleife über alle VBProject<\/b>-Elemente. In der Schleife prüfen wir, ob die Eigenschaft FileName <\/b>des aktuellen VBProject<\/b>-Objekts mit dem Namen der mit CodeDb <\/b>referenzierten Add-In-Datenbank übereinstimmt.<\/p>\n Ist das der Fall, wird die For Each<\/b>-Schleife verlassen und objVBProjectAddIn <\/b>referenziert das VBA-Projekt der Add-In-Datenbank.<\/p>\n Dann prüfen wir, ob dieses VBProject<\/b>-Objekt vielleicht eine Referenz auf die zu untersuchende Datenbank enthält – beispielsweise, weil die vorherige Untersuchung einen Fehler ausgelöst hat und der Verweis nicht gelöscht wurde.<\/p>\n Deshalb durchlaufen wir im Anschluss alle Verweise des VBA-Projekts der Add-In-Datenbank. Hat einer der Verweise den gleichen Pfad wie die zu untersuchende Datenbank, landet dieser Verweis in der Variablen ref <\/b>und die Schleife wird verlassen.<\/p>\n In der Regel sollte ref <\/b>hier nicht gefüllt sein, sodass wir die Referenz auf die zu untersuchende Datei neu setzen. Dazu greifen wir über die AddFromFile<\/b>-Methode auf die mit strDatei <\/b>übergebene Datenbankdatei zu und setzen somit einen Verweis auf das enthaltene VBA-Projekt.<\/p>\n Dann wollen wir noch mit der Variablen objVBProject <\/b>auf das VBA-Projekt des so referenzierten Elements verweisen. Dazu durchlaufen wir nun alle VBA-Projekte des mit objVBE <\/b>referenzierten VBA-Editors, bis wir ein VB-Projekt gefunden haben, dessen Wert aus der Eigenschaft FileName <\/b>mit dem aus strDatei <\/b>übereinstimmt.<\/p>\n Damit gehen wir dann in den Teil der Routine, den wir bereits eingangs kennengelernt haben – und in dem wir die Inhalte der einzelnen Module aneinanderfügen und über die Variable strVBA <\/b>in einer Textdatei speichern.<\/p>\n Deren Name stellen wir indes anders als zuvor zusammen, und zwar aus dem Verzeichnis der Add-In-Datenbank, der mit intDatei <\/b>übergebenen Zahl (1 <\/b>oder 2<\/b>) und der Dateiendung .vba.txt<\/b>.<\/p>\n Den Dateinamen der so gespeicherten Datei geben wir dann als Funktionswert an die aufrufende Routine zurück.<\/p>\n Installieren der Add-In-Datei<\/b><\/p>\n Damit fehlt lediglich noch das Installieren der Add-In-Datenbank. Dazu schließen Sie die .accda<\/b>-Datei und rufen mit dem Ribbon-Eintrag Datenbanktools|Add-Ins|Add-Ins|Add-In-Manager <\/b>den Add-In-Manager auf.<\/p>\n Hier betätigen Sie die Schaltfläche Neues hinzufügen… <\/b>und wählen aus dem folgenden Dialog die Add-In-Datenbank aus.<\/p>\n Diese wird nach dem Hinzufügen wie in Bild 10 in der Liste der Add-Ins angezeigt. Die Add-In-Datenbank wird dadurch automatisch in den Add-In-Ordner kopiert und Access verwendet von nun an diese Kopie der Datenbank, wenn Sie das Add-In vom Add-In-Menü aus aufrufen.<\/p>\nPublic Sub <\/span>CodeKomplettExportieren()\r\n Dim <\/span>objVBE As <\/span>VBIDE.VBE\r\n Dim <\/span>objVBProject As <\/span>VBIDE.VBProject\r\n Dim <\/span>objVBComponent As <\/span>VBIDE.VBComponent\r\n Dim <\/span>objCodemodule As <\/span>VBIDE.CodeModule\r\n Dim <\/span>strVBA As String<\/span>\r\n Dim <\/span>strDateiname As String<\/span><\/pre>\n Set<\/span> objVBE = VBE\r\n Set<\/span> objVBProject = objVBE.ActiveVBProject<\/pre>\n For Each objVBComponent In objVBProject.VBComponents<\/pre>\n
Set<\/span> objCodemodule = objVBComponent.CodeModule\r\n strVBA = strVBA & \"============================\" _\r\n & vbCrLf<\/span>\r\n strVBA = strVBA & objVBComponent.Name & vbCrLf<\/span>\r\n strVBA = strVBA & \"============================\" _\r\n & vbCrLf<\/span><\/pre>\n strVBA = strVBA & objCodemodule.Lines(1, _\r\n objCodemodule.CountOfLines) & vbCrLf<\/span>\r\n Next<\/span> objVBComponent<\/pre>\n strDateiname = CurrentDb.Name & \".vba.txt\"\r\n Open strDateiname For Output As <\/span>#1\r\n Print #1, strVBA\r\n Close #1\r\nEnd Sub<\/span><\/pre>\n\n
![\"Optionen](\"..\/fileadmin\/_temp_\/2020_04\/pic_1248_002.png\")
<\/p>\n![\"Vergleich](\"..\/fileadmin\/_temp_\/2020_04\/pic_1248_003.png\")
<\/p>\nPublic Sub <\/span>TextPadMitDateienOeffnen()\r\n Shell \"C:Program FilesTextPad 8TextPad.exe \"\"\" _\r\n & c:...Datei1.vba.txt\"\" \"\"c:...Datei2.vba.txt\"\"\"\r\nEnd Sub<\/span><\/pre>\n![\"Add-In-Einstellungen](\"..\/fileadmin\/_temp_\/2020_04\/pic_1248_005.png\")
<\/p>\n![\"Datenbank-Eigenschaften\"](\"..\/fileadmin\/_temp_\/2020_04\/pic_1248_004.png\")
<\/p>\nPublic Function <\/span>Autostart()\r\n DoCmd.OpenForm \"frmVBAVergleich\", WindowMode:=acDialog\r\nEnd Function<\/span><\/pre>\n![\"Optionen-Tabelle](\"..\/fileadmin\/_temp_\/2020_04\/pic_1248_007.png\")
<\/p>\n![\"Das](\"..\/fileadmin\/_temp_\/2020_04\/pic_1248_006.png\")
<\/p>\n![\"Auswahl](\"..\/fileadmin\/_temp_\/2020_04\/pic_1248_008.png\")
<\/p>\nPrivate Sub <\/span>cmdToolAuswaehlen_Click()\r\n Dim <\/span>strTool As String<\/span>\r\n strTool = OpenFileName(CurrentProject.Path, _\r\n \"Tool für Textvergleich auswählen\", _\r\n \"Anwendung (*.exe)\")\r\n Me!txtTool = strTool\r\n SchaltflaecheAktivieren Nz(Me!txtDatenbank1), Nz(Me!txtDatenbank2), Nz(Me!txtTool)\r\nEnd Sub<\/span><\/pre>\nPrivate Sub <\/span>txtDatenbank1_Change()\r\n SchaltflaecheAktivieren Me!txtDatenbank1.Text, Nz(Me!txtDatenbank2), Nz(Me!txtTool)\r\nEnd Sub<\/span>\r\nPrivate Sub <\/span>txtDatenbank2_Change()\r\n SchaltflaecheAktivieren Nz(Me!txtDatenbank1), Me!txtDatenbank2.Text, Nz(Me!txtTool)\r\nEnd Sub<\/span>\r\nPrivate Sub <\/span>txtTool_Change()\r\n SchaltflaecheAktivieren Nz(Me!txtDatenbank1), Nz(Me!txtDatenbank2), Me!txtTool.Text\r\nEnd Sub<\/span><\/pre>\nPrivate Sub <\/span>SchaltflaecheAktivieren(strDatenbank1 As <\/span>_\r\n String, strDatenbank2 As String<\/span>, strTool As String<\/span>)\r\n Dim <\/span>bolAktiviert As Boolean<\/span>\r\n If <\/span>Len<\/span>(Dir(strDatenbank1)) > 0 Then<\/span>\r\n If <\/span>Len<\/span>(Dir(strDatenbank2)) > 0 Then<\/span>\r\n If <\/span>Len<\/span>(Dir(strTool)) > 0 Then<\/span>\r\n bolAktiviert = True<\/span>\r\n End If<\/span>\r\n End If<\/span>\r\n End If<\/span>\r\n Me!cmdVergleichStarten.Enabled = bolAktiviert\r\nEnd Sub<\/span><\/pre>\n![\"Starten](\"..\/fileadmin\/_temp_\/2020_04\/pic_1248_009.png\")
<\/p>\n![\"Anzeige](\"..\/fileadmin\/_temp_\/2020_04\/pic_1248_010.png\")
<\/p>\n