<\/p>\n
Beim Fertigstellen einer jeden Ausgabe von Access im Unternehmen sind auch einige Beispieldatenbanken anzupassen. Manchmal sind einige Schritte nötig, um diese rund zu machen, mindestens aber muss das Startformular mit dem Hinweis auf die Herkunft der Datenbank hinzugefügt werden. Und jedes Mal nehmen die notwendigen Schritte einige Zeit in Anspruch. Zeit, ein Access-Add-In zu entwickeln, das einem diese Arbeit abnimmt. Dieser Beitrag zeigt, wie Sie solche Aufgaben viel einfacher erledigen.<\/b><\/p>\n
Ziel des Add-Ins<\/b><\/p>\n
Was genau soll der Formular-Importer erledigen In dem Fall, der zum Erstellen dieses Add-Ins führte, sollen einige Beispieldatenbanken immer mit dem gleichen Startformular ausgestattet werden, die sich lediglich durch einige Kleinigkeiten unterscheiden – beispielsweise den Titeltext, die Ausgabe oder das Objekt, das nach dem Schließen des Formulars aufgerufen werden soll. Dabei kann es sich um ein Formular oder einen Bericht handeln, aber auch um ein VBA-Modul, eine Tabelle, eine Abfrage oder gar das Beziehungsfenster.<\/p>\n
Außerdem soll das Formular beim Start der Anwendung angezeigt werden. Dazu müssen Sie normalerweise einen manuellen Eintrag in den Access-Optionen beziehungsweise in den Start-Optionen (Access 2003 und älter) durchführen.<\/p>\n
Das Add-In soll als Menü-Add-In implementiert werden. Bei Auswahl des Add-Ins soll dieses eine kleine Benutzeroberfläche anbieten, mit der die variablen Anteile des Formulars geändert werden. Außerdem soll es eine Option geben, mit der Sie festlegen können, ob das Formular als Startformular angezeigt werden soll.<\/p>\n
Bislang habe ich immer ein Startformular von Anwendung zu Anwendung vererbt, indem ich es von der aktuell bearbeiteten Access-Datenbank aus importiert, angepasst und als Startformular festgelegt habe. Kein Problem, wenn man das nur einmal durchführt, aber wenn diese Aufgabe acht- bis zehnmal hintereinander erledigt werden muss …<\/p>\n
Wohin soll es gehen<\/b><\/p>\n
Die Grundanforderungen sind definiert. Die Frage ist: Gibt es weitere Anwendungsfälle für das Formular Sollte man es beispielsweise als globalen Formular-Container verwenden, mit dem man nicht nur eines, sondern gleich alle möglichen Formulare verwaltet, die man vielleicht mal in mehr als einer Anwendung benötigt Nein. In diesem Fall halten wir die Lösung möglichst klein und arbeiten auf das Ziel hin. Dabei werden wir einige interessante Techniken entdecken, die Grundlagen für eine größere Lösung sein können.<\/p>\n
Technische Hintergründe<\/b><\/p>\n
Ein Formular soll gespeichert und nach Bedarf in die aktuell geöffnete Anwendung importiert werden. Wie kommt die Formularvorlage in das Add-In Wo speichern wir es Und wie bekommen wir es am einfachsten in die Zielanwendung Diese Fragen klären wir, bevor wir mit der Entwicklung beginnen. Vielleicht kennen Sie bereits die beiden Befehle SaveAsText <\/b>und LoadFromText<\/b>, mit denen Sie Access-Objekte (mit Ausnahme von Tabellen) als Textdatei speichern und wieder einlesen können. Diese können die Arbeit beim Einlesen und Wiederherstellen von Formularen erheblich erleichtern. Theoretisch ist es natürlich auch möglich, das Formular auf Basis der Vorlage komplett neu anzulegen und Steuerelement für Steuerelement, Eigenschaft für Eigenschaft aufzubauen. Theoretisch sollte sich dies sogar innerhalb einiger Schleifen über Steuerelemente und Eigenschaft realisieren lassen, aber die Methode mit der Textdatei als Zwischenstation ist doch etwas leichtgängiger.<\/p>\n
Wir starten mit dem Import, der logischerweise bei geöffneter Quelldatei erfolgt. Hier soll das Formular, ausgestattet mit entsprechenden Platzhaltern, die durch eckige Klammern markiert werden, in das Add-In eingelesen werden. Dazu wird das Formular per SaveAsText <\/b>als Textdatei gespeichert und mit den herkömmlichen Anweisungen zum Einlesen von Textdateien in eine Tabelle der Add-In-Datenbank geschrieben.<\/p>\n
Wenn Platzhalter verwendet werden sollen, müssen diese vor dem Importieren in die Add-In-Datenbank eingebaut werden. Dies gilt sowohl für Eigenschaften von Steuerelementen als auch für Codezeilen – mehr dazu später.<\/p>\n
Nach dem Öffnen der Zieldatei wird diese Vorlage nach Eingabe der Texte für die Platzhalter aus der Tabelle ins Dateisystem gespeichert und mit der Methode LoadFromText <\/b>in die Zieldatenbank importiert.<\/p>\n
Add-In vorbereiten<\/b><\/p>\n
Als Add-In-Datenbank verwenden wir eine herkömmliche Datenbankdatei, die wir um einige Elemente erweitern. Vergeben Sie für die Add-In-Datenbank die Dateiendung .mda <\/b>beziehungsweise .accda<\/b>, damit der Add-In-Manager diese Datenbanken gleich als Add-In-Datenbanken erkennt.<\/p>\n
Legen Sie dann eine Tabelle namens USysRegInfo <\/b>an, die beim Installieren des Add-Ins mit dem Add-In-Manager einige Einträge zur die Registry hinzufügt. Dadurch wird die Datenbank beim Start von Access in die Liste der verfügbaren Add-Ins aufgenommen und gemeinsam mit den übrigen Menü-Add-Ins angezeigt. Die Tabelle sieht wie in Bild 1 aus.<\/p>\n
![\"pic002.png\"](\"..\/fileadmin\/_temp_\/2012_03\/FormularImporter-web-images\/pic002.png\")
<\/p>\n
Bild 1: Die Tabelle USysRegInfo enthält Informationen, die beim Installieren des Add-Ins in die Registry eingetragen werden.<\/span><\/b><\/p>\n Fügen Sie außerdem ein Standardmodul namens mdlAddIn <\/b>zur Datenbank hinzu (Sie können diesem auch einen anderen Namen geben). Tragen Sie dort die folgende Funktion ein:<\/p>\n Diese öffnet beim Auswählen des Menü-Add-Ins das angegebene Formular. Dieses müssen Sie natürlich auch noch anlegen. Für den Anfang möchten wir einfach nur Formulardefinitionen in einer Tabelle der Add-In-Datenbank speichern, wozu ein Kombinationsfeld und eine OK<\/b>-Schaltfläche ausreichen.<\/p>\n Formular im Add-In speichern<\/b><\/p>\n Die Formulardefinitionen sollen in einer Tabelle namens frmFormulare<\/b> gespeichert werden. Diese Tabelle ist wie in Bild 2 aufgebaut. Sie enthält zwei Felder zum Speichern des Formularnamens und des Formularcodes.<\/p>\n Bild 2: Tabelle zum Speichern der Formulardefinitionen<\/span><\/b><\/p>\n Wie aber gelangen die Formulardefinitionen in diese Tabelle Dazu benutzen wir die bereits erwähnten beiden Steuerelemente im Formular frmFormularImporter<\/b> (s. Bild 3). Das Kombinationsfeld frmFormulare<\/b> soll alle Formulare der Datenbank anzeigen, von der aus Sie das Add-In geöffnet haben. Dazu können wir nicht einfach eine Abfrage auf Basis der Tabelle MSysObjects <\/b>als Datenherkunft verwenden, die ja auch alle Formulare enthält – Sie würden dann auf die Tabelle MSysObjects <\/b>der Add-In-Datenbank zugreifen und deren Formulare anzeigen. Also definieren wir eine Tabelle namens tblFormulareTemp<\/b>, die nur ein Feld namens Formular <\/b>enthält, und füllen diese in einer Schleife über alle Elemente der Auflistung AllForms <\/b>der Host-Datenbank mit den jeweiligen Formularnamen.<\/p>\n Bild 3: Formular mit den ersten Steuerelementen zum Importieren der Formulardefinitionen<\/span><\/b><\/p>\n Diese Tabelle wird anschließend, sortiert nach den Formularnamen, als Datensatzherkunft des Kombinationsfeldes festgelegt. Wie aber unterscheiden wir zwischen der Host- und der Add-In-Datenbank Dies gelingt mithilfe der Varianten zweier Funktionen, die den Zugriff auf die beiden Instanzen erlauben. Mit CodeDB <\/b>und CodeProject <\/b>greifen Sie auf die Add-In-Datenbank zu, mit CurrentDB <\/b>und CurrentProject <\/b>auf die Host-Datenbank. Deshalb greifen wir mit CurrentProject <\/b>auf die AllForms<\/b>-Auflistung zu und schreiben diese dann über das mit der Funktion CodeDB <\/b>gewonnene Database<\/b>-Objekt in die entsprechende Tabelle der Add-In-Datenbank (s. Listing 1<\/a><\/span>).<\/p>\n Listing 1: Anzeigen aller Formulare der Host-Tabelle im Kombinationsfeld<\/p>\n Damit kann der Benutzer nun zumindest schon einmal die in der Host-Datenbank enthaltenen Formulare anzeigen und das zu importierende Formular auswählen.<\/p>\n Formulardefinition einlesen<\/b><\/p>\n Nach der Auswahl soll ein Klick auf die Speichern<\/b>-Taste die Formular-Definition in die Tabelle tblFormulare <\/b>schreiben. Die entsprechende Ereignisprozedur speichert die Formulardefinition zunächst mit der SaveAsText<\/b>-Methode in eine Textdatei namens frmXXX.txt<\/b>, und zwar im gleichen Verzeichnis wie die Add-In-Datei (s. Listing 2<\/a><\/span>). Dann verwendet sie die Open<\/b>-, Input$<\/b>– und Close<\/b>-Methode, um den Inhalt der Textdatei in eine String<\/b>-Variable zu schreiben. Der Formularcode wird dann per AddNew<\/b>, Zuweisen der Feldwerte und Update <\/b>in ein Recordset auf Basis der Tabelle tblFormulare<\/b> geschrieben – das aber nur, wenn noch kein gleichnamiges Formular gespeichert wurde. Falls doch, kann der Benutzer einen alternativen Namen angeben oder das vorhandene Formular überschreiben. Gibt der Benutzer keinen neuen Namen ein, wird der vorhandene Datensatz gelöscht. Danach ermittelt die Prozedur den Wert des Primärschlüsselfeldes des soeben neu angelegten Datensatzes. Mit diesem ruft sie die Prozedur PlatzhalterSpeichern <\/b>auf – dazu später mehr. <\/p>\n Listing 2: Einlesen einer Formulardefinition in die Add-In-Datenbank<\/p>\n <\/p>\n Schließlich löscht die Kill<\/b>-Methode die temporär gespeicherte Textdatei wieder und weitere Steuerelemente werden aktualisiert – auch auf diese kommen wir später zurück. Der erste Teil wäre somit geschafft – Sie können den Code kompletter Formulare in eine Tabelle der Add-In-Datenbank schreiben.<\/p>\n Platzhalter verwalten<\/b><\/p>\n Wie bereits erwähnt, wollen wir einen gewissen flexiben Anteil beim Erstellen eines neuen Formulars auf Basis eines im Add-In gespeicherten Formulars erhalten. Deshalb können Sie in den Eigenschaften und im Code des zu speichernden Formulars Platzhalter unterbringen, die in eckigen Klammern eingefasst sein müssen. Diese werden gleich beim Einlesen des Formulars in eine weitere Tabelle namens tblPlatzhalter <\/b>geschrieben (s. Bild 4).<\/p>\n Bild 4: Diese Tabelle speichert Platzhalter und ihre Standardwerte.<\/span><\/b><\/p>\n Diese Aufgabe führt die Prozedur PlatzhalterSpeichern<\/b> aus Listing 3<\/a><\/span> durch. Sie erwartet den Code des Formulars sowie die ID des Datensatzes in der Tabelle tblFormulare<\/b> als Parameter. Die Prozedur ermittelt mit der InStr<\/b>-Funktion zunächst die Position der ersten öffnenden eckigen Klammer ([<\/b>). Liefert dies einen Wert größer 0<\/b>, sucht die Prozedur auch noch nach der passenden schließenden Klammer. Der Ausdruck dazwischen könnte ein Platzhalter sein, aber auch die Zuweisung des Wertes [Event Procedure] <\/b>zu einer Ereigniseigenschaft des Formulars. Diese sollen natürlich nicht als Platzhalter erkannt werden, daher übergeht die Prozedur diese. In allen anderen Fällen schreibt die Prozedur den Namen des Platzhalters in die Tabelle tblPlatzhalter<\/b>. Dieser Vorgang wird so lange wiederholt, bis keine öffnende Klammer mehr gefunden wird.<\/p>\n Listing 3: Speichern der in einem Formular enthaltenen Platzhalter<\/p>\n Unterformular zur Anzeige der Platzhalter<\/b><\/p>\n Die Platzhalter werden in einem Unterformular namens sfmPlatzhalter <\/b>verwaltet. Dieses verwendet die Tabelle tblPlatzhalter <\/b>als Basis-Datenherkunft. Diese wird jedoch gelegentlich aktualisiert – beispielsweise, wenn soeben ein neues Formular samt Platzhalter-Datensätzen eingelesen wurde.<\/p>\n Dies führt die folgende Prozedur durch:<\/p>\n Wie dieses Formular in das Hauptformular frmFormularimporter <\/b>eingefügt wird, beschreiben wir weiter unten.<\/p>\n Gespeicherte Formulare anzeigen<\/b><\/p>\n Da Sie mit dem FormularImporter<\/b> mehr als nur ein Formular speichern und in andere Datenbanken einfügen können, soll das Formular frmFormularImporter <\/b>diese in einem Listenfeld anzeigen. Von dort aus können Formularvorlagen zum Einfügen in die aktuelle Datenbank oder zum Löschen ausgewählt werden. Mit den entsprechenden Schaltflächen und mit integriertem Unterformular sieht das Formular frmFormularImporter <\/b>im Entwurf nun wie in Bild 5 aus.<\/p>\n Bild 5: Das vollständige Hauptformular in der Entwurfsansicht<\/span><\/b><\/p>\n Löschen einer Formulardefinition<\/b><\/p>\n Die Schaltfläche cmdLoeschen <\/b>soll eine in der Tabelle tblFormulare <\/b>gespeicherte Formulardefinition nach der Auswahl des entsprechenden Eintrags im Listenfeld lstFormulare <\/b>löschen. Die durch diese Schaltfläche ausgelöste Prozedur sieht so aus:<\/p>\n Die Prozedur löscht den angegebenen Datensatz, aktualisiert dann das Listenfeld und aktiviert den ersten Eintrag. Anschließend wird die Prozedur PlatzhalterAktualisieren <\/b>aufgerufen, damit das Unterformular die zur aktuell ausgewählten Formularvorlage passenden Platzhalter anzeigt.<\/p>\n Anlegen von Formularen<\/b><\/p>\n Kommen wir zu der Funktion, die aus dem in der Tabelle tblFormulare <\/b>gespeicherten Formularcode ein neues Formular in der Zieltabelle erstellt. Die beim Mausklick auf die Schaltfläche Erstellen <\/b>ausgelöste Prozedur finden Sie in Listing 4<\/a><\/span>.<\/p>\n Listing 4: Anlegen eines neuen Formulars auf Basis einer gespeicherten Formulardefinition<\/p>\n Die Prozedur prüft zunächst, ob der Benutzer überhaupt einen Eintrag des Listenfeldes lstFormulare <\/b>ausgewählt hat (s. Bild 6). Dies ist eigentlich immer der Fall – außer, wenn das Listenfeld überhaupt keinen Eintrag enthält.<\/p>\n Bild 6: Das fertige Formular zum Hinzufügen gespeicherter Formulare zur aktuell geöffneten Datenbank<\/span><\/b><\/p>\n Wurde eine Formulardefinition ausgewählt, öffnet die Prozedur zunächst eine Datensatzgruppe auf Basis der Tabelle tblFormulare<\/b>, die genau den ausgewählten Datensatz enthält. Die Variablen strForm <\/b>und strFormularname <\/b>nehmen den Code des Formulars sowie den in der Tabelle gespeicherten Namen auf.<\/p>\n Der Formularcode wird direkt im Anschluss durch die Funktion PlatzhalterErsetzen <\/b>gejagt, die sich darum kümmert, die Platzhalter durch die in der Tabelle tblPlatzhalter <\/b>gespeicherten Werte zu ersetzen. Details zu dieser Funktion finden Sie weiter unten. Das Extrakt wird nochmal um eine Zeichenkette erleichtert, die eine Eigenschaft von Formularen unter neueren Access-Versionen repräsentiert und die beim Einlesen in älteren Versionen mit der Methode LoadFromText <\/b>Fehler verursacht.<\/p>\n Dann speichert die Prozedur den Formularcode unter dem Namen frmXXX.txt <\/b>im Verzeichnis der Add-In-Datenbank. Bevor die entstandene Datei mit der Methode LoadFromText <\/b>zur Zieldatenbank hinzugefügt wird, prüft die Prozedur noch, ob gegebenenfalls bereits ein Formular mit gleichem Namen wie das Ausgangsformular in der Datenbank vorhanden ist. Ist dies der Fall, wird das Importieren des Formulars mit einer entsprechenden Meldung abgebrochen.<\/p>\n Anderenfalls liest die Methode LoadFromText <\/b>den Formularcode in Form eines neuen Formulars in die Zieldatenbank ein.<\/p>\n Einen Schritt später prüft die Prozedur noch, ob das Kontrollkästchen chkStandardformular <\/b>im Formular frmFormularImporter <\/b>aktiviert ist.<\/p>\n In diesem Fall soll das frisch importierte Formular als Startformular der Zieldatenbank festgelegt werden. Dies erledigt die Funktion SetProperty<\/b>, die ebenfalls im Anschluss erläutert wird. Fertig – das gewünschte Formular ist nun einsatzbereit und wird nach Wunsch gleich beim Öffnen der Anwendung eingeblendet!<\/p>\n Formular als Standardformular festlegen<\/b><\/p>\n Die Funktion SetProperty <\/b>aus Listing 5<\/a><\/span> stellt die übergebene Eigenschaft auf den angegebenen Wert ein. Wichtig ist dabei, dass eine Datenbank gegebenenfalls noch über keine entsprechende Eigenschaft verfügt und diese erst noch angelegt werden muss. Auch dies führt die Prozedur durch.<\/p>\n Listing 5: Diese Funktion stellt eine Formular-Eigenschaft ein.<\/p>\n Prüfen, ob ein Formular vorhanden ist<\/b><\/p>\n Im Gegensatz zu der Funktion, die oft eingesetzt wird, um zu prüfen, ob ein Formular mit dem angegebenen Namen geöffnet ist, verwendet die Prozedur FormularVorhanden <\/b>einen etwas anderen Ansatz (s. Listing 6<\/a><\/span>).<\/p>\n Listing 6: Prüfen, ob ein Formular bereits in einer Datenbank vorliegt<\/p>\n Sie durchläuft alle Einträge der Auflistung AllForms <\/b>und liefert den Wert True<\/b>, sobald es ein Formular mit dem angegebenen Namen findet. Anderenfalls gibt sie den Wert False <\/b>zurück.<\/p>\n Platzhalter ersetzen<\/b><\/p>\nPublic Function Autostart()\r\n DoCmd.OpenForm "frmFormularImporter", WindowMode:=acDialog\r\nEnd Function<\/pre>\n
![\"pic003.png\"](\"..\/fileadmin\/_temp_\/2012_03\/FormularImporter-web-images\/pic003.png\")
<\/p>\n![\"pic001.png\"](\"..\/fileadmin\/_temp_\/2012_03\/FormularImporter-web-images\/pic001.png\")
<\/p>\nPrivate Sub Form_Load()\r\n Dim db As dao.Database\r\n Dim rst As dao.Recordset\r\n Dim i As Integer\r\n Set db = CodeDb\r\n db.Execute "DELETE FROM tblFormulareTemp", dbFailOnError\r\n Set rst = db.OpenRecordset("tblFormulareTemp", dbOpenDynaset)\r\n For i = 0 To CurrentProject.AllForms.Count - 1\r\n rst.AddNew\r\n rst!Formular = CurrentProject.AllForms(i).Name\r\n rst.Update\r\n Next i\r\n Me!cboFormulare.RowSource = "SELECT * FROM tblFormulareTemp ORDER BY Formular"\r\nEnd Sub<\/pre>\nPrivate Sub cmdSpeichern_Click()\r\n Dim strForm As String\r\n Dim strFormname As String\r\n Dim dbc As dao.Database\r\n Dim rst As dao.Recordset\r\n Dim lngFormularID As Long\r\n Set dbc = CodeDb\r\n SaveAsText acForm, Me!cboFormulare, CodeProject.Path & "\\frmXXX.txt"\r\n Open CodeProject.Path & "\\frmXXX.txt" For Input As #1\r\n strForm = Input$(LOF(1), #1)\r\n strFormname = Me!cboFormulare\r\n If Not dbc.OpenRecordset("SELECT * FROM tblFormulare WHERE Formularname = ''" & strFormname & "''").EOF Then\r\n strFormname = InputBox("Es ist bereits ein Formular namens ''" & strFormname _\r\n & "'' vorhanden. Geben Sie einen anderen Namen ein, anderenfalls wird das vorhandene " _\r\n & "Formular gelöscht.", "Formular schon vorhanden", strFormname)\r\n End If\r\n dbc.Execute "DELETE FROM tblFormulare WHERE Formularname = ''" & strFormname & "''", dbFailOnError\r\n Set rst = dbc.OpenRecordset("SELECT * FROM tblFormulare WHERE 1=2", dbOpenDynaset)\r\n rst.AddNew\r\n rst!Formularname = strFormname\r\n rst!Formularcode = strForm\r\n lngFormularID = rst!FormularID\r\n rst.Update\r\n PlatzhalterSpeichern strForm, lngFormularID\r\n Close #1\r\n Kill CodeProject.Path & "\\frmXXX.txt"\r\n Me!lstFormulare.Requery\r\n Me!lstFormulare = lngFormularID\r\n PlatzhalterAktualisieren\r\nEnd Sub<\/pre>\n![\"pic004.png\"](\"..\/fileadmin\/_temp_\/2012_03\/FormularImporter-web-images\/pic004.png\")
<\/p>\nPrivate Sub PlatzhalterSpeichern(strForm As String, lngFormularID As Long)\r\n Dim dbc As dao.Database\r\n Dim lngStart As Long\r\n Dim lngStop As Long\r\n Dim strPlatzhalter As String\r\n Set dbc = CodeDb\r\n lngStart = InStr(1, strForm, "[")\r\n Do While lngStart > 0\r\n lngStop = InStr(lngStart + 1, strForm, "]")\r\n strPlatzhalter = Mid(strForm, lngStart + 1, lngStop - lngStart - 1)\r\n Select Case strPlatzhalter\r\n Case "Event Procedure"\r\n Case Else\r\n dbc.Execute "INSERT INTO tblPlatzhalter(Platzhalter, FormularID) VALUES(''" _\r\n & strPlatzhalter & "'', " & lngFormularID & ")", dbFailOnError\r\n End Select\r\n lngStart = InStr(lngStop + 1, strForm, "[")\r\n Loop\r\nEnd Sub<\/pre>\nPrivate Sub PlatzhalterAktualisieren()\r\n If Me!lstFormulare.ListCount > 0 Then\r\n Me!sfmPlatzhalter.Form.RecordSource = "SELECT * FROM tblPlatzhalter WHERE " _\r\n & "FormularID = " & Me!lstFormulare\r\n Else\r\n Me!sfmPlatzhalter.Form.RecordSource = "SELET * FROM tblPlatzhalter"\r\n End If\r\nEnd Sub<\/pre>\n
![\"pic005.png\"](\"..\/fileadmin\/_temp_\/2012_03\/FormularImporter-web-images\/pic005.png\")
<\/p>\nPrivate Sub cmdLoeschen_Click()\r\n Dim dbc As dao.Database\r\n Set dbc = CodeDb\r\n dbc.Execute "DELETE FROM tblFormulare WHERE FormularID = " & Me!lstFormulare\r\n Me!lstFormulare.Requery\r\n Me!lstFormulare = Me!lstFormulare.ItemData(0)\r\n PlatzhalterAktualisieren\r\nEnd Sub<\/pre>\n
Private Sub cmdErstellen_Click()\r\n Dim dbc As dao.Database\r\n Dim rst As dao.Recordset\r\n Dim strForm As String\r\n Dim strFormularname As String\r\n Dim strDateiname As String\r\n Set dbc = CodeDb\r\n If Not IsNull(Me!lstFormulare) Then\r\n Set rst = dbc.OpenRecordset("SELECT * FROM tblFormulare WHERE FormularID = " _\r\n & Me!lstFormulare)\r\n strForm = rst!Formularcode\r\n strFormularname = rst!Formularname\r\n strForm = PlatzhalterErsetzen(strForm, Me!lstFormulare)\r\n strForm = Replace(strForm, "NoSaveCTIWhenDisabled =1", "")\r\n strDateiname = CodeProject.Path & "\\frmXXX.txt"\r\n Open strDateiname For Output As #1\r\n Print #1, strForm\r\n Close #1\r\n If FormularVorhanden(strFormularname) Then\r\n MsgBox "Es ist bereits ein Formular gleichen Namens vorhanden. " _\r\n & "Das Formular wurde nicht angelegt."\r\n Else\r\n LoadFromText acForm, strFormularname, strDateiname\r\n If Me!chkStandardformular Then\r\n SetProperty "StartupForm", dbText, strFormularname\r\n End If\r\n End If\r\n End If\r\nEnd Sub<\/pre>\n![\"pic006.png\"](\"..\/fileadmin\/_temp_\/2012_03\/FormularImporter-web-images\/pic006.png\")
<\/p>\nFunction SetProperty(strProperty As String, varType As Variant, varValue As Variant) As Boolean\r\n Dim db As dao.Database\r\n Dim prp As dao.Property\r\n On Error GoTo Fehler\r\n Set db = CurrentDb\r\n db.Properties(strProperty) = varValue\r\n SetProperty = True\r\nEnde:\r\n On Error Resume Next\r\n ''Hier finale Anweisungen\r\n Exit Function\r\nFehler:\r\n Select Case Err.Number\r\n Case 3270\r\n Set prp = db.CreateProperty(strProperty, varType, varValue)\r\n db.Properties.Append prp\r\n Case 0\r\n Case Else\r\n SetProperty = False\r\n Resume Ende\r\n End Select\r\nEnd Function<\/pre>\n
Private Function FormularVorhanden(strFormular As String) As Boolean\r\n Dim i As Integer\r\n For i = 0 To CurrentProject.AllForms.Count - 1\r\n If CurrentProject.AllForms(i).Name = strFormular Then\r\n FormularVorhanden = True\r\n Exit Function\r\n End If\r\n Next i\r\nEnd Function<\/pre>\n
![\"pic007.png\"](\"..\/fileadmin\/_temp_\/2012_03\/FormularImporter-web-images\/pic007.png\")
<\/p>\n![\"pic008.png\"](\"..\/fileadmin\/_temp_\/2012_03\/FormularImporter-web-images\/pic008.png\")
<\/p>\n![\"pic009.png\"](\"..\/fileadmin\/_temp_\/2012_03\/FormularImporter-web-images\/pic009.png\")
<\/p>\n