{"id":55001332,"date":"2021-12-01T00:00:00","date_gmt":"2021-12-10T07:39:35","guid":{"rendered":"http:\/\/access-im-unternehmen.aix-dev.de\/aiu\/?p=1332"},"modified":"-0001-11-30T00:00:00","modified_gmt":"-0001-11-30T00:00:00","slug":"Formulare_per_VBA_erstellen","status":"publish","type":"post","link":"https:\/\/access-im-unternehmen.de\/Formulare_per_VBA_erstellen\/","title":{"rendered":"Formulare per VBA erstellen"},"content":{"rendered":"

\"\"<\/p>\n

Warum sollte man Formulare per VBA erstellen, wenn Microsoft Access doch die gute alte, etwas in die Jahre gekommene Entwurfsansicht dafür bereitstellt Ganz einfach: Weil es für den effizient arbeitenden Access-Entwickler immer wieder Aufgaben gibt, die er einfach nicht von Hand erledigen möchte. Oder weil der Access-Entwickler immer wiederkehrende Aufgaben in ein Access-Add-In oder ein COM-Add-In auslagern möchte. Und dort gibt es nun einmal keine Entwurfsansicht – dort ist VBA-Code gefragt, um neue Formulare zu erstellen und die gewünschten Steuerelemente auf das Formular zu bringen. Dieser Beitrag liefert alle Techniken, die zum Erstellen von Formularen und zum Ausstatten mit Steuerelementen notwendig sind.<\/b><\/p>\n

Neues, leeres Formular erstellen<\/h2>\n

Mit einer ersten Funktion wollen wir ein neues, leeres Formular mit einem vorher festgelegten Namen erstellen. Das erledigt die Funktion CreateNewForm<\/b>. Diese erwartet als Parameter den Namen, den das Formular nach dem Erstellen erhalten soll:<\/p>\n

Public Sub <\/span>CreateNewForm(strName As String<\/span>) \r\n     Dim <\/span>frm As <\/span>Form\r\n     Dim <\/span>strNameTemp As String<\/span>\r\n     Set<\/span> frm = CreateForm()\r\n     strNameTemp = frm.Name\r\n     DoCmd.Close acForm, frm.Name, acSaveYes\r\n     DoCmd.Rename strName, acForm, strNameTemp\r\nEnd Sub<\/span><\/pre>\n
Die Prozedur deklariert Variablen für das neue Form<\/b>-Element (frm<\/b>) und für den temporären von Access beim Erstellen vergebenen Namen (strNameTemp<\/b>). Dann erstellt es mit der CreateForm<\/b>-Funktion ein neues Formular. CreateForm <\/b>liefert einen Verweis auf das neu erstellte Form<\/b>-Objekt zurück, welches wir mit der Variablen frm <\/b>referenzieren. Wir würden nun gern den Namen des Formulars einstellen, aber das ist nicht ohne weiteres möglich: Die Eigenschaft Name <\/b>des Form<\/b>-Objekts ist nämlich schreibgeschützt. Wie also dem Formular den gewünschten Namen geben Klar: Wir könnten es einfach nach dem Speichern und Schließen umbenennen, dafür gibt es die DoCmd.Rename<\/b>-Methode. Allerdings erwartet die auch den vorherigen Namen des Formulars, und den kennen wir nicht. Allerdings können wir diesen zuvor mit frm.Name <\/b>auslesen und speichern ihn in der Variablen strNameTemp<\/b>. Danach schließen wir dann das Formular mit der Methode DoCmd.Close <\/b>und den Parametern acForm <\/b>für den Objekttyp, frm.Name <\/b>für den Namen des zu schließenden Objekts und acSaveYes<\/b>, damit die Änderungen an dem neu erstellten Formular ohne Rückfrage gespeichert werden.<\/p>\n
Nach dem Schließen rufen wir dann DoCmd.Rename <\/b>auf und übergeben mit dem ersten Parameter den neuen Namen, mit dem zweiten den Objekttyp (acForm<\/b>) und mit dem dritten den vorherigen Objektnamen.<\/p>\n
Rufen wir diese Prozedur nun wie folgt auf, legt dies ein neues, leeres Formular unter dem angegebenen Namen an, das direkt im Navigationsbereich erscheint:<\/p>\n
CreateNewForm \"frmNeuesFormular\"<\/pre>\n
Formular bereits vorhanden<\/h2>\n
Wenn man diese Prozedur zwei Mal hintereinander mit dem gleichen Formularnamen aufruft, erhält man die Meldung aus Bild 1. Diese wird durch den Versuch ausgelöst, dem neuen Formular den Namen eines bereits vorhandenen Formulars zu übergeben. Dem können wir bereits zuvor vorbeugen, indem wir abfragen, ob bereits ein Formular dieses Namens vorhanden ist. Ob ein Formular bereits vorhanden ist, können wir auf verschiedene Arten prüfen. Wir könnten zum Beispiel versuchen, es zu öffnen, oder wir durchlaufen eine der Auflistungen der Formulare.<\/p>\n
\"Meldung<\/p>\n
Bild 1: Meldung beim Versuch, einem Formular einen bereits vorhandenen Namen zu geben<\/span><\/b><\/p>\n
Wir wählen letztere Variante. Die Funktion heißt ExistsForm <\/b>und erwartet den Formularnamen als Parameter. Sie liefert das Ergebnis als Booleanwert zurück. Hier deklarieren wir für die Formulare eine Variable des Typs AccessObject<\/b>. Warum nun AccessObject <\/b>und nicht Form<\/b> wie oben in der Prozedur CreateNewForm<\/b> Weil die dort verwendete Funktion CreateForm <\/b>ein Objekt des Typs Form <\/b>erstellt, die Auflistung CurrentProject.AllForms<\/b>, die wir durchsuchen wollen, jedoch Elemente des Typs AccessObjects <\/b>liefert.<\/p>\n
Mit objForm <\/b>durchlaufen wir in einer For Each<\/b>-Schleife alle Elemente der Auflistung CurrentProject.AllForms <\/b>und prüfen, ob das aktuell mit objForm <\/b>referenzierte Formular den mit strForm <\/b>übergebenen Namen hat. Falls ja, stellen wir den Funktionswert auf True <\/b>ein und verlassen die Funktion. Wenn die Funktion alle Elemente aus CurrentProject.AllForms <\/b>durchläuft, ohne dass das passende Formular gefunden wird, liefert sie den Rückgabewert False <\/b>(also den Standardwert für Rückgabewerte des Datentyps Boolean<\/b>):<\/p>\n
Public Function <\/span>ExistsForm(strForm As String<\/span>) As Boolean<\/span>\r\n     Dim <\/span>objForm As <\/span>AccessObject\r\n     For Each objForm In CurrentProject.AllForms\r\n         If <\/span>objForm.Name = strForm Then<\/span>\r\n             ExistsForm = True<\/span>\r\n             Exit Function<\/span>\r\n         End If<\/span>\r\n     Next<\/span> objForm\r\nEnd Function<\/span><\/pre>\n
Formular neu erstellen<\/h2>\n
Wenn das Formular bereits existiert, können wir den Benutzer fragen, ob das vorhandene Formular überschrieben werden soll. Ist das der Fall, löschen wir das Formular und erstellen es neu. Dazu erweitern wir die Prozedur CreateNewForm <\/b>wie in Listing 1. Hier fügen wir direkt hinter der Deklaration der Variablen einen Aufruf der Funktion ExistsForm <\/b>ein.<\/p>\n
Public Function <\/span>CreateNewForm(strName As String<\/span>) As Boolean<\/span>\r\n     Dim <\/span>frm As <\/span>Form\r\n     Dim <\/span>strNameTemp As String<\/span>\r\n     If <\/span>ExistsForm(strName) Then<\/span>\r\n         If MsgBox<\/span>(\"Formular ''\" & strName & \"'' ist bereits vorhanden. Überschreiben\", vbYesNo + vbExclamation, _\r\n                 \"Formular überschreiben\") = vbYes Then\r\n             If <\/span>DeleteForm(strName) = False<\/span> Then<\/span>\r\n                 Exit Function<\/span>\r\n             End If<\/span>\r\n         Else<\/span>\r\n             Exit Function<\/span>\r\n         End If<\/span>\r\n     End If<\/span>\r\n     Set<\/span> frm = CreateForm()\r\n     strNameTemp = frm.Name\r\n     frm.Visible = True<\/span>\r\n     DoCmd.Close acForm, frm.Name, acSaveYes\r\n     DoCmd.Rename strName, acForm, strNameTemp\r\n     CreateNewForm = True<\/span>\r\nEnd Function<\/span><\/pre>\n
Listing 1: Erstellen eines neuen Formulars<\/span><\/b><\/p>\n
Liefert diese den Wert True<\/b>, dann zeigen wir ein Meldungsfenster an, das den Benutzer fragt, ob er das Formular überschreiben möchte. Falls ja, rufen wir eine Funktion namens DeleteForm <\/b>auf (siehe weiter unten) und übergeben den Namen des zu löschenden Formulars. Diese könnte fehlschlagen, weil beispielsweise das zu löschende Formular gerade geöffnet ist. In diesem Fall soll die Prozedur einfach verlassen werden – die passende Fehlermeldung soll die Funktion DeleteForm <\/b>liefern. Wenn der Benutzer die Frage, ob das vorhandene Formular gelöscht werden soll, mit Nein <\/b>antwortet, soll die Prozedur auch verlassen werden.<\/p>\n
Nur wenn das Formular noch nicht existiert oder gelöscht werden konnte, werden die anschließenden Schritte zum Erstellen des neuen Formulars ausgeführt.<\/p>\n
Löschen eines vorhandenen Formulars<\/h2>\n
Wenn das Formular bereits vorhanden ist und der Benutzer es überschreiben möchte, müssen wir es löschen. Dazu haben wir die Funktion DeleteForm <\/b>definiert, die den Namen des zu löschenden Formulars entgegennimmt und einen Boolean<\/b>-Wert zurückliefert.<\/p>\n
Die Funktion probiert bei deaktivierter eingebauter Fehlerbehandlung aus, ob das Formular mit DoCmd.DeleteObject <\/b>gelöscht werden kann. Falls ja, erhält die Funktion den Rückgabewert True<\/b>. Anderenfalls gibt die Funktion die entsprechende Fehlermeldung aus Err.Description <\/b>aus und gibt den Standardwert False <\/b>als Funktionsergebnis an die aufrufende Prozedur zurück:<\/p>\n
Public Function <\/span>DeleteForm(strName As String<\/span>) As Boolean<\/span>\r\n     On Error Resume Next<\/span>\r\n     DoCmd.DeleteObject acForm, strName\r\n     If <\/span>Err.Number = 0 Then<\/span>\r\n         DeleteForm = True<\/span>\r\n     Else<\/span>\r\n         MsgBox<\/span> Err.Description, vbCr<\/span>itical + vbOKOnly, _\r\n             \"Löschen fehlgeschlagen\"\r\n     End If<\/span>\r\nEnd Function<\/span><\/pre>\n
Damit haben wir bereits eine Funktion zum Erstellen eines neuen Formulars, das allerdings noch komplett leer ist und für das wir auch noch keine Eigenschaften eingestellt haben.<\/p>\n
Formular weiterverarbeiten<\/h2>\n
Nun stehen zwei Aufgaben an: Die erste ist das Einstellen verschiedener Eigenschaften für das Formular. Die zweite ist das Erstellen von Steuerelementen im Formular. Letzteres beschreibt der Beitrag Steuerelemente erstellen <\/b>(www.access-im-unternehmen.de\/1336<\/b>). Um die Eigenschaften kümmern wir uns jetzt gleich.<\/p>\n
Um Eigenschaften einstellen zu können, benötigen wir einen Verweis auf das Formular in der Entwurfsansicht. Das heißt also, dass wir das Formular auch öffnen müssen. Da stellt sich die Frage: Könnten wir mit der Funktion CreateNewForm<\/b> nicht direkt einen Verweis auf das neu erstellte und in der Formularansicht geöffnete Formular zurückgeben Das könnten wir tun, wir müssten dazu das Formular allerdings auch in dieser Funktion wieder öffnen.<\/p>\n
Das Schließen ist dort unbedingt nötig, da wir es sonst nicht umbenennen können. Da wir nicht wissen, ob und wie das Formular nach dem Erstellen direkt weiterverarbeitet werden soll, geben wir einfach nur einen Boolean-Wert zurück, der angibt, ob das Formular erfolgreich erstellt wurde.<\/p>\n
Eigenschaften des Formulars einstellen<\/h2>\n
In der Prozedur, welche die Funktion CreateNewForm <\/b>aufgerufen hat, können wir nun das Formular in der Entwurfsansicht öffnen und die gewünschten Änderungen vornehmen.<\/p>\n
Wie bereits erwähnt, wollen wir uns in diesem Beitrag zunächst um das Einstellen der verschiedenen Eigenschaften des Formulars kümmern und schauen uns diese dabei im Detail an. Das Öffnen gestalten wir wie folgt:<\/p>\n
Public Sub <\/span>Test_CreateNewForm()\r\n     Dim <\/span>frm As <\/span>Form\r\n     Dim <\/span>strForm As String<\/span>\r\n     strForm = \"frmNeuesFormular\"\r\n     If <\/span>CreateNewForm(strForm) = True<\/span> Then<\/span>\r\n         DoCmd.OpenForm strForm, acDesign\r\n         Set<\/span> frm = Forms(strForm)\r\n         With<\/span> frm\r\n             ''Eigenschaften einstellen\r\n         End With<\/span>\r\n     End If<\/span>\r\nEnd Sub<\/span><\/pre>\n
Hier schreiben wir den Namen des zu erstellenden Formulars direkt in eine Variable, weil wir diesen mehr als einmal benötigen und anschließende Änderungen so nur an einer Stelle erfolgen müssen. Dann erstellen wir das neue Formular mit der Funktion CreateNewForm<\/b>.<\/p>\n
Ist dies erfolgreich, öffnen wir das neu erstellte Formular mit DoCmd.OpenForm <\/b>in der Entwurfsansicht. Dazu stellen wir den zweiten Parameter View<\/b> auf acDesign <\/b>ein.<\/p>\n
Damit wir danach komfortabel die Eigenschaften des Formulars einstellen können, referenzieren wir das Formular dann über die Forms<\/b>-Auflistung und den Namen des Formulars mit der Form<\/b>-Variablen frm<\/b>. Für frm <\/b>stellen wir dann die nachfolgend beschriebenen Eigenschaften ein.<\/p>\n
Einstellungen für die Titelleiste<\/h2>\n
Die Titelleiste des Formulars (siehe Bild 2) verwendet gleich mehrere Eigenschaften.<\/p>\n
\"Elemente<\/p>\n
Bild 2: Elemente der Titelleiste eines Formulars<\/span><\/b><\/p>\n