<\/p>\n
Für Einsteiger sind die Formular-Assistenten von Access sicher eine hilfreiche Einrichtung. Fortgeschrittene Entwickler verwenden diese jedoch eher selten – sie haben eine individuell verschiedene Vorgehensweise, diese zu erstellen, mit Datenherkunft und Steuerelementen zu befüllen und Eigenschaften und Ereignisse festzulegen. Wenn man aber immer wieder ähnliche Formulare benötigt, ist das ständige Neuerstellen vergeudete Zeit: Per Copy and Paste oder auch mit ein paar Zeilen Code gelingt dies doch deutlich schneller.<\/b><\/p>\n
Die schnellste Möglichkeit, ein Formular zu erstellen, dass man bereits in ganz ähnlicher Weise produziert hat, ist das Kopieren dieses Formulars – zumindest, wenn es sich in der gleichen Datenbank befindet. Sollten Sie es für eine andere Anwendung erstellt haben, können Sie es über die Import-Funktion von Access ebenfalls schnell hinzufügen.<\/p>\n
Es gibt aber noch eine Alternative: Warum programmieren Sie sich nicht eine kleine Funktion, die Ihnen immer wiederkehrende Schritte beim Erstellen von Formularen abnimmt In diesem Beitrag stellen wir Ihnen die notwendigen Grundlagen für das Erstellen von Formularen und Steuerelementen samt Eigenschaften vor.<\/p>\n
Ein anderer Grund für das dynamische Erstellen eines Formulars wäre ein Unterformular, dessen Felder erst zur Laufzeit bekannt sind. Ein gutes Beispiel dafür ist die Lösung zum Beitrag Seriendruck mit Access und Word <\/b>(www.access-im-unternehmen.de\/<\/b>). Hier können wir zwar direkt eine Tabelle oder Abfrage als Datenherkunft zuweisen (unter VBA etwa mit dem Ausdruck Me.sfm.SourceObject = "Table.tblBeispiel" <\/b>beziehungsweise "Tabelle.tblBeispiel" <\/b>in älteren Access-Versionen). Wenn das Unterformular aber auch noch die für ein Formular üblichen Ereignisse bereitstellen soll, um etwa auf änderungen der enthaltenen Daten reagieren zu können, ist das Erstellen eines Formulars zur Laufzeit eine Alternative.<\/p>\n
Das Anlegen von Ereignisprozeduren für zur Laufzeit erstellte Formulare demonstrieren wir in einem späteren Beitrag.<\/p>\n
Formulare erstellen<\/b><\/p>\n
Das reine Erstellen eines Formulars geht ganz einfach von der Hand und kann gleich im Direktfenster des VBA-Editors geschehen: Die Application<\/b>-Methode CreateForm <\/b>erzeugt im Handumdrehen ein Formular, ganz so als ob Sie es über den entsprechenden Menüeintrag erledigt hätten.<\/p>\n
Unter Access 2003 oder unter der Dokumentfensteroption <\/b>namens Überlappende Fenster <\/b>unter Access 2007 erscheint das Formular allerdings lediglich in Form seiner Titelleiste, was dem Modus Minimiert<\/b> entspricht. Das lässt sich allerdings leicht mit folgender Anweisung ändern:<\/p>\n Anschließend können wir das Formular nach Bedarf speichern. Dies gelingt nur unter Angabe des Formularnamens, der allerdings beim Aufruf der CreateForm<\/b>-Methode dynamisch erzeugt wird (in der deutschen Version nacheinander Formular1<\/b>, Formular2<\/b>, …).<\/p>\n Um wirklich das richtige Formular zu speichern, speichern wir gleich beim Anlegen einen Verweis auf das neue Formular in einer Objektvariablen namens frm<\/b>. Dies alles geschieht bereits in einer kleinen Prozedur, die wir anschließend Schritt für Schritt erweitern:<\/p>\n Wenn Sie das so gespeicherte Formular umbenennen möchten, verwenden Sie die Anweisung DoCmd.Rename<\/b>. Diese setzt allerdings voraus, dass das zu ändernde Formular geschlossen ist.Wenn das Formular geschlossen ist, haben wir aber keinen Zugriff mehr auf die Objektvariable frm<\/b>, um den aktuellen Namen zu ermitteln. Also speichern wir diesen zuvor in der Variablen strForm <\/b>zwischen, schließen das Formular und benennen es erst dann um:<\/p>\n Das Ergebnis dieser acht Zeilen ist ein neues Formular mit dem gewünschten Namen. Um die Prozedur dynamischer zu gestalten, übergeben Sie den gewünschten Namen (hier noch frmBeispiel<\/b>) mit einem Parameter:<\/p>\n Steuerelemente zum Formular hinzufügen<\/p>\n Steuerelemente fügen Sie einem Formular in der Entwurfsansicht mit der CreateControl<\/b>-Methode des Application<\/b>-Objekts hinzu.<\/p>\n Diese erwartet die folgenden Parameter:<\/p>\n Wenn Sie ein Steuerelement mit der CreateControl<\/b>-Methode anlegen, können Sie einen Verweis darauf in einer entsprechenden Variablen speichern:<\/p>\n Der Hintergrund ist, dass Sie so noch weitere Einstellungen vornehmen können – etwa um bei Kombinationsfeldern die Nachschlagefeld<\/b>-Eigenschaften aus der Felddefinition auszulesen und abzubilden.<\/p>\n Formular mit Daten füllen und in der Datenblattansicht anzeigen<\/b><\/p>\n Manche Entwickler arbeiten in Unterformularen sehr viel mit der Datenblattansicht. Sie zeigt die Daten übersichtlich an, ermöglicht das Bearbeiten und auch das Sortieren oder Filtern.<\/p>\n Bauen wir also eine Prozedur, die ein mit der vorherigen Prozedur erstelltes Formular so umwandelt, dass es die gewünschte Datenherkunft erhält und die Felder der Datenherkunft anzeigt.<\/p>\n Diese Prozedur verwendet zwei Parameter: den Namen des Formulars und den Namen der zu verwendenden Datenherkunft beziehungsweise den entsprechenden SQL-Ausdruck. Vor dem Aufruf dieser Funktion sollten Sie bereits ein leeres Formular mit der Prozedur FormularErstellen<\/b> erzeugt haben.<\/p>\n Die folgenden Zeilen sorgen außerdem dafür, dass ein eventuell bereits bestehendes Formular gelöscht und die richtigen Parameter übergeben werden:<\/p>\n Die Prozedur DatenblattEinrichten <\/b>öffnet das mit dem Parameter strFormname <\/b>benannte Formular in der Entwurfsansicht und füllt die Objektvariable frm <\/b>mit einem Verweis darauf, um später komfortabel auf seine Eigenschaften zugreifen zu können (s. Listing 1).<\/p>\n Listing 1: Füllen eines leeren Formulars mit den Steuerelementen für die Anzeige der Datenblattansicht<\/p>\n Danach wird ein Recordset<\/b>-Objekt mit den Datensätzen der mit dem Parameter strRecordsource <\/b>angegebenen Tabelle oder Abfrage gefüllt. Dieses benötigen wir, um die Felder der Datenherkunft zu durchlaufen und die entsprechenden Steuerelemente im Formular anzulegen.<\/p>\n Man könnte die Felder zwar auch über ein TableDef<\/b>– beziehungsweise ein QueryDef<\/b>-Objekt auslesen, aber dazu müsste man noch prüfen, ob es sich bei dem in strRecordsource <\/b>angegebenen Objekt um eine Tabelle oder Abfrage handelt.<\/p>\n Dies sparen wir uns aus Bequemlichkeit und weil wir wissen, dass das Erstellen von Formularen wohl nicht zur Laufzeit geschehen wird und somit nicht wichtig für die Performance ist (TableDef <\/b>und QueryDef <\/b>enthalten nur die Definition, Recordset <\/b>enthält auch Daten und könnte ein wenig mehr Zeit zum Füllen beanspruchen).<\/p>\n Beim Durchlaufen der einzelnen Felder der Datenherkunft über die Fields<\/b>-Auflistung geschehen folgende Schritte:<\/p>\n <\/p>\n Wenn Sie das Formular auf Basis der Tabelle tblAdressen<\/b> der Beispieldatenbank erstellt haben, sieht das Formular nach dem Öffnen wie in Bild 1 aus. Ein Wechsel in die Entwurfsansicht liefert allerdings ein überraschendes Bild: Dort befindet sich offensichtlich nur ein einziges Steuerelement (siehe Bild 2)! Doch das ist nicht der Fall, denn die Prozedur hat lediglich alle Steuerelemente übereinander angelegt beziehungsweise Größe und Position nach dem Anlegen nicht mehr geändert.<\/p>\n Bild 1: Ein per VBA-Code erstelltes Formular in der Datenblattansicht<\/span><\/b><\/p>\n Bild 2: Die Entwurfsansicht ist nur schwer bearbeitbar …<\/span><\/b><\/p>\n Das ist für die Datenblattansicht eigentlich nicht relevant, aber für die spätere Bearbeitung eher unpraktisch – wozu erstellen wir vollautomatisch ein Formular, wenn wir anschließend doch wieder mehr Handgriffe ausführen müssen, um das Formular unseren Wünschen anzupassen<\/p>\n Also erweitern wir die Prozedur noch um einige Zeilen, welche die Steuerelemente übersichtlich anordnen – etwa so wie in Bild 3. Diese Abbildung berücksichtigt gleichzeitig eine Einstellung der Größe entsprechend des für die angezeigten Daten benötigten Platzes. Außerdem sollen auch die Spaltenbreiten der Datenblattansicht entsprechend den bereits in der Datenherkunft enthaltenen Daten optimiert werden.<\/p>\n Bild 3: So sollte das Formular im Entwurf aussehen.<\/span><\/b><\/p>\n Formulare für die Formularansicht erstellen<\/b><\/p>\n Nachdem wir die Datenblattansicht abgedeckt haben (wenn auch mit einer etwas komprimierten Entwurfsansicht), widmen wir uns einer etwas komplizierteren Aufgabe: Dem Erstellen eines Formulars, das auch in der Entwurfs- und somit in der Formularansicht ein akzeptables Bild abgibt. Dabei wollen wir folgende Voraussetzungen erfüllen:<\/p>\n Prozedur zum Erstellen von Formularen mit passenden Steuerelementbreiten<\/b><\/p>\n Die Prozedur FormularansichtEinrichten <\/b>(s. Listing 2) hat viel mehr zu erledigen als die Prozedur zum Erstellen eines Formulars in der Datenblattansicht. Nach dem Deklarationsteil öffnet diese zunächst das leere, mit der weiter oben vorgestellten Prozedur FormularErstellen <\/b>erstellte Formular in der Entwurfsansicht und verweist mit der Form<\/b>-Objektvariablen frm <\/b>darauf. Dann füllt es die Variable db <\/b>mit einem Verweis auf das aktuelle Database<\/b>-Objekt und erzeugt eine Datensatzgruppe mit den im Formular anzuzeigenden Daten.<\/p>\n Listing 2: Anlegen eines neuen Formulars in der Formularansicht<\/p>\n Bevor auch nur ein einziges Steuerelement angelegt werden kann, brauchen wir den Abstand der gebundenen Steuerelemente vom rechten Rand. Dieser hängt maßgeblich von der Breite der Beschriftungsfelder ab, die sich wiederum am enthaltenen Text in der verwendeten Schriftart, Schriftgröße und weiteren Schrifteigenschaften orientiert. Die maximale Breite der Beschriftungstexte liefert die Funktion GetSizeAllLabels<\/b>, die wir weiter unten beschreiben, mit dem Parameter lngLabelX<\/b>.<\/p>\n Nachdem wir diese wertvolle Information erhalten haben, beginnt die Prozedur, alle Steuerelemente der Datenherkunft in einer For Each<\/b>-Schleife abzuarbeiten. Wir müssen zunächst herausfinden, mit welchem Steuerelementtyp die Feldinhalte abgebildet werden sollen. Standardmäßig ist dies acTextBox<\/b>. Bei Nachschlagefeldern oder Ja\/Nein<\/b>-Feldern können dies beispielsweise auch Kombinationsfelder oder Kontrollkästchen sein. Auskunft darüber gibt eine Eigenschaft des betroffenen Field<\/b>-Objekts, die wir mit dem Ausdruck fld.Properties("DisplayControl") <\/b>ermitteln. Diese Eigenschaft ist aber nur vorhanden, wenn ein anderes Steuerelement als ein Textfeld verwendet werden soll. Da der Zugriff auf eine nicht vorhandene Property <\/b>einen Fehler auslöst, deaktivieren wir die Fehlerbehandlung hier kurzfristig.<\/p>\n Die folgende Anweisung erstellt dann mit der Methode CreateControl <\/b>auch gleich das gewünschte Steuerelement. Der Abstand vom linken Rand des Formulars entspricht der Breite der Bezeichungsfelder plus einem Leerraum, der Abstand vom oberen Rand stammt aus der Variablen sngTop<\/b>. Diese Variable wird jeweils um die Höhe des aktuell hinzugefügten Steuerelements erhöht.<\/p>\n Auch beim Steuerelement möchten wir die optimale Breite ermitteln, die sich nach den bereits im Recordset enthaltenen Daten richtet. Sie sollten also vor dem Anlegen des Formulars mit dieser Prozedur ein paar repräsentative Daten in die zugrunde liegende Tabelle eintragen. Die Breite des Steuerelements liefert die Prozedur GetMaximalSizeControl<\/b>, die wir ebenfalls im Anschluss beschreiben.<\/p>\n Nun folgt eine kleine Sonderbehandlung für Memofelder: Da diese oft lange Texte enthalten, sollen sie mehrzeilig ausgelegt werden. Ein Memofeld identifizieren wir, indem wir die Eigenschaft FieldSize <\/b>auslesen, die nur für Memofelder vorliegt. Auch hier setzen wir vorbeugend die oben verwendete Fehlerbehandlung ein. Das Memofeld passen wir an, indem wir die von GetMaximalSizeControl <\/b>ermittelte Breite durch vier teilen und die Höhe mit vier multiplizieren.<\/p>\n Anschließend weist die Prozedur dem Steuerelement die ermittelten Maße zu, Gleiches gilt für die Datenherkunft, die wir der Eigenschaft SourceField <\/b>des Field<\/b>-Objekts entnehmen.<\/p>\n Nun folgt eine Sonderbehandlung für die verschiedenen Steuerelementtypen, die erstens einen Steuerelementnamen mit einem entsprechenden Präfix vergibt und zweitens die Eigenschaften Datensatzherkunft<\/b>, Spaltenanzahl <\/b>und Spaltenbreite <\/b>für Kombinations- und Listenfelder einstellt.<\/p>\n Erst jetzt wird das Bezeichnungsfeld für das jeweilige Steuerelement hinzugefügt. Warum erst jetzt Nun: Die Bindung des Bezeichnungsfelds an ein Steuerelement wird über das Setzen des Parameters Parent <\/b>der CreateControl<\/b>-Methode erzeugt, was das Vorhandensein des Steuerelements, an welches das Bezeichnungsfeld gebunden werden soll, zwingend voraussetzt. Dies und weitere Arbeiten übernimmt die Funktion BuildLabel<\/b>.<\/p>\n Schließlich wird die Höhe des neuen Steuerelements zur Variablen sngTop <\/b>hinzuaddiert – auch hier unter Berücksichtigung eines kleinen Puffers. Auf die gleiche Weise legt die Prozedur die übrigen Steuerelemente an. Zu guter Letzt weist sie dem Formular die richtige Datenherkunft zu, stellt Formularansicht <\/b>als Standardansicht <\/b>ein und speichert das Formular.<\/p>\n Breite der Bezeichnungsfelder ermitteln<\/b><\/p>\n Die Funktion GetSizeAllLabels <\/b>(s. Listing 3) ermittelt die maximale Breite der Bezeichnungsfelder des Formulars. Sie erwartet einen Verweis auf das Recordset mit den Daten und auf ein Standardsteuerelement als Parameter und liefert Höhe und Breite zurück.<\/p>\n Listing 3: Ermitteln der maximalen Breite der Bezeichnungsfelder eines Formulars<\/p>\n Die Funktion durchläuft alle Felder in einer For Each<\/b>-Schleife und speichert zunächst den Feldnamen in der Variablen strCaption<\/b>. Felder können aber auch noch eine vom Feldnamen abweichende Beschriftung aufweisen, welche in der nur dann vorhandenen Eigenschaft Caption <\/b>gespeichert wird.<\/p>\n Um den Fehler beim Auslesen einer nicht vorhandenen Property <\/b>zu umgehen, wird auch hier kurzzeitig die Fehlerbehandlung ausgeschaltet.<\/p>\n Dann kommt der Auftritt der nicht dokumentierten Funktion TwipsFromFont <\/b>der WizHook<\/b>-Klasse: Diese liefert, wenn man ihr die Schrifteigenschaften und den Text übergibt, die genaue Breite und Höhe des Textes zurück.<\/p>\n Der Rest ist Fleißarbeit: Die Prozedur prüft für jedes neue Bezeichnungsfeld, ob die benötigte Breite größer als die bis dato größte Breite ist, und ersetzt diese gegebenenfalls.<\/p>\n Breite und Höhe eines Steuerelements ermitteln<\/p>\n Die Funktion GetMaximalSizeControl <\/b>ermittelt die Breite eines Steuerelements (s. Listing 4).<\/p>\n Listing 4: Ermitteln der maximalen Breite eines Steuerelements<\/p>\n Das ist ungleich schwieriger als das Ermitteln der Breite der Beschriftungsfelder, denn wir müssen ja alle vorhandenen Feldwerte nach dem Text mit dem größten Platzbedarf durchsuchen.<\/p>\n Und manchmal wird es noch komplizierter, denn etwa bei Kombinations- und Listenfeldern müssen wir uns auch noch um deren Datensatzherkunft kümmern.<\/p>\n Die Funktion erwartet wiederum einen Verweis auf das aktuelle Database<\/b>-Objekt, die Datenherkunft, einen Verweis auf ein Steuerelement des Formulars, um die Schrifteigenschaften auszulesen, sowie einen Verweis auf das zu untersuchende Feld der Datenherkunft.<\/p>\n Gleich zu Beginn erfahren Kontrollkästchen eine Sonderbehandlung: Sie werden durch ein herkömmliches Textfeld ersetzt, da sie nicht die Eigenschaften aufweisen, die für die Analyse mit der auch hier verwendeten TwipsFromFont<\/b>-Funktion nötig sind.<\/p>\n Die Sonderbehandlung für Kombinations- und Listenfelder startet mit deren Erkennung über die Eigenschaft DisplayType<\/b>, die Sie bereits weiter oben kennengelernt haben.<\/p>\n Trifft die Routine auf ein solches Steuerelement, dann untersucht sie nicht die Werte des eigentlichen Steuerelements, sondern die der Datensatzherkunft des Steuerelements, also der Tabelle oder Abfrage, aus der das Steuerelement seine Werte bezieht.<\/p>\n Hier ermittelt die Routine zunächst die erste Spalte, die das Steuerelement anzeigt, in der Regel also die erste Spalte nach dem gebundenen Feld (die Berechnung der Breite bezieht sich also immer auf die Anzeige einer einzigen Spalte – sollen etwa in einem Listenfeld mehrere Spalten angezeigt werden, ist manuelle Nacharbeit nötig).<\/p>\n Wenn es sich beim aktuellen Steuerelement um ein Textfeld handelt, untersucht die Routine nachfolgend ganz einfach die Inhalte des an dieses Steuerelement gebundenen Feldes.<\/p>\n Die Ermittlung der benötigten Breite ist prinzipiell mit dem für die Breite der Bezeichnungsfelder angewandten Algorithmus identisch. Für Kombinations- und Listenfelder gibt es noch ein paar Anpassungen.<\/p>\n So wird für Kombinationsfelder noch ein kleiner Aufschlag für die Schaltfläche zum Aufklappen des Kombinationsfeldes eingerechnet, und die Höhe von Listenfeldern wird auf acht festgesetzt.<\/p>\n Erstellen der Bezeichnungsfelder<\/b><\/p>\n Im Anschluss an das Erstellen eines jeden Steuerelements ruft die Prozedur FormularansichtEinrichten <\/b>die Funktion BuildLabel <\/b>auf, die das passende Bezeichnungsfeld hinzufügt (s. Listing 5).<\/p>\n Listing 5: Erstellen eines Bezeichnungsfeld für ein Steuerelement<\/p>\n Diese Funktion erwartet einen Verweis auf das Formular-Objekt, in dem das Bezeichnungsfeld erstellt werden soll, einen Verweis auf das Feld, aus dem die im betroffenen Steuerelement anzuzeigenden Daten stammen, einen Verweis auf das Steuerelement selbst, den Typ des Steuerelements, die Höhe, Breite und vertikale Position des zu erzeugenden Bezeichnungsfeldes.<\/p>\n Daraus erzeugt sie dann schon das Bezeichnungsfeld mit den wesentlichen Eigenschaften. Die Prozedur muss noch untersuchen, ob sie den Feldnamen oder den eventuell in der Eigenschaft Caption <\/b>gespeicherten Ausdruck als Beschriftung verwendet.<\/p>\n Außerdem ermittelt sie über die Eigenschaft AddColon <\/b>der Standardeinstellungen des aktuellen Steuerelementtyps, ob der Beschriftung ein Doppelpunkt angehängt werden soll.<\/p>\n Zusammenfassung und Ausblick<\/b><\/p>\n Die vorgestellten Routinen zum Erstellen von Formularen auf Basis von Tabellen oder Abfragen nehmen Ihnen viel Arbeit ab, wenn Sie schnell ein Formular in der Datenblattansicht oder in der Formularansicht erstellen möchten und Ihnen die Vorlagen von Access nicht gefallen.<\/p>\n Gleichzeitig gibt es eine Menge Erweiterungs- und Verbesserungspotenzial. Beginnen wir mit der Datenblattansicht: Hier wäre es leicht, mithilfe der Funktion GetMaximalSizeControl <\/b>die maximale Breite eines Steuerelements zu ermitteln und diese auf die Breite der entsprechenden Spalte des Datenblatts anzuwenden.<\/p>\n Die relevante Eigenschaft lautet ColumnWidth<\/b>. Beachten Sie, dass Sie auch die Breite der Spaltenüberschrift mit einbeziehen, damit diese nicht abgeschnitten wird, wenn die Inhalte weniger Platz als diese beanspruchen sollten.<\/p>\n Für die Formulare in der Formularansicht gibt es noch zahlreiche weitere Vorschläge:<\/p>\nDoCmd.Restore<\/pre>\n
Public Sub FormularErstellen()\r\nDim frm As Form\r\nSet frm = CreateForm\r\nDoCmd.Restore\r\nDoCmd.Save acForm, frm.Name\r\nEnd Sub<\/pre>\n
Dim frm As Form\r\nDim strFormTemp As String\r\nSet frm = CreateForm\r\nstrFormTemp = frm.Name\r\nDoCmd.Restore\r\nDoCmd.Save acForm, strFormTemp\r\nDoCmd.Close acForm, strFormTemp\r\nDoCmd.Rename "frmBeispiel", acForm, strFormTemp<\/pre>\n
Public Sub FormularErstellen(strFormname As String)\r\n...\r\nDoCmd.Rename strFormName, acForm, strFormTemp\r\nEnd Sub<\/pre>\n
\n
Dim ctl As Control\r\nSet ctl = Application.CreateControl("frmTest", acTextBox, acDetail, ...)<\/pre>\nDim strFormname As String\r\nDim strRecordsource As String\r\nstrFormname = "frmBeispiel"\r\nstrRecordsource = "SELECT * FROM tblAdressen"\r\nOn Error Resume Next\r\nDoCmd.DeleteObject acForm, strFormname\r\nOn Error GoTo 0\r\nFormularErstellen strFormname\r\nDatenblattEinrichten strFormname, strRecordsource<\/pre>\n
Public Sub DatenblattEinrichten(strFormname As String, strRecordsource As String)\r\n ''...Deklaration\r\n DoCmd.OpenForm strFormname, acDesign\r\n Set frm = Forms(strFormname)\r\n Set db = CurrentDb\r\n Set rst = db.OpenRecordset(strRecordsource, dbOpenDynaset)\r\n For Each fld In rst.Fields\r\n intControlType = acTextBox\r\n On Error Resume Next\r\n intControlType = fld.Properties("DisplayControl")\r\n On Error GoTo 0\r\n Set ctl = Application.CreateControl(strFormname, intControlType, acDetail)\r\n ctl.ControlSource = fld.SourceField\r\n Select Case intControlType\r\n Case acComboBox\r\n Set cbo = ctl\r\n With cbo\r\n .RowSource = fld.Properties("RowSource")\r\n .ColumnCount = fld.Properties("ColumnCount")\r\n .ColumnWidths = fld.Properties("ColumnWidths")\r\n End With\r\n End Select\r\n Set lbl = Application.CreateControl(strFormname, acLabel, acDetail, ctl.Name)\r\n lbl.Caption = fld.Name\r\n On Error Resume Next\r\n lbl.Caption = fld.Properties("Caption")\r\n On Error GoTo 0\r\n Next fld\r\n frm.RecordSource = strRecordsource\r\n frm.DefaultView = acDefViewDatasheet\r\n DoCmd.Close acForm, frm.Name, acSaveYes\r\nEnd Sub<\/pre>\n\n
![\"pic001.png\"](\"..\/fileadmin\/_temp_\/2010_02\/GenerischeFormulare-web-images\/pic001.png\")
<\/p>\n![\"pic003.png\"](\"..\/fileadmin\/_temp_\/2010_02\/GenerischeFormulare-web-images\/pic003.png\")
<\/p>\n![\"pic002.png\"](\"..\/fileadmin\/_temp_\/2010_02\/GenerischeFormulare-web-images\/pic002.png\")
<\/p>\n\n
Public Sub FormularansichtEinrichten(strFormname As String, strRecordsource As String)\r\n ''... Deklaration\r\n DoCmd.OpenForm strFormname, acDesign\r\n Set frm = Forms(strFormname)\r\n Set db = CurrentDb\r\n Set rst = db.OpenRecordset(strRecordsource, dbOpenDynaset)\r\n Call GetSizeAllLabels(rst, frm.DefaultControl(acTextBox), lngLabelX, lngLabelY)\r\n sngTop = 100\r\n For Each fld In rst.Fields\r\n intControlType = acTextBox\r\n On Error Resume Next\r\n intControlType = fld.Properties("DisplayControl")\r\n On Error GoTo 0\r\n Set ctl = Application.CreateControl(strFormname, intControlType, acDetail, , , lngLabelX _\r\n + 300, sngTop)\r\n Call GetMaximalSizeControl(db, strRecordsource, ctl, fld, lngControlX, lngControlY)\r\n intFieldsize = 0\r\n On Error Resume Next\r\n intFieldsize = fld.FieldSize\r\n If Err.Number = 0 Then ''Memo\r\n lngControlX = lngControlX \/ 4\r\n lngControlY = lngControlY * 4\r\n End If\r\n On Error GoTo 0\r\n ctl.Width = lngControlX\r\n ctl.Height = lngControlY\r\n ctl.ControlSource = fld.SourceField\r\n Select Case intControlType\r\n Case acComboBox\r\n ctl.RowSource = fld.Properties("RowSource")\r\n ctl.ColumnCount = fld.Properties("ColumnCount")\r\n ctl.ColumnWidths = fld.Properties("ColumnWidths")\r\n ctl.Name = "cbo" & fld.Name\r\n Case acListBox\r\n ctl.RowSource = fld.Properties("RowSource")\r\n ctl.ColumnCount = fld.Properties("ColumnCount")\r\n ctl.ColumnWidths = fld.Properties("ColumnWidths")\r\n ctl.Name = "lst" & fld.Name\r\n Case acCheckBox\r\n ctl.Name = "chk" & fld.Name\r\n Case acTextBox\r\n ctl.Name = "txt" & fld.Name\r\n End Select\r\n Call BuildLabel(frm, fld, ctl, intControlType, lngLabelX, lngLabelY, sngTop)\r\n sngTop = sngTop + ctl.Height + 40 ''für Abstand\r\n Next fld\r\n frm.RecordSource = strRecordsource\r\n frm.DefaultView = acDefViewSingle\r\n DoCmd.Close acForm, frm.Name, acSaveYes\r\nEnd Sub<\/pre>\nPublic Function GetSizeAllLabels(rst As DAO.Recordset, ctl As Control, lngX As Long, lngY As Long)\r\n Dim fld As DAO.Field\r\n Dim strCaption As String\r\n Dim lngXTemp As Long\r\n Dim lngYTemp As Long\r\n For Each fld In rst.Fields\r\n strCaption = fld.Name\r\n On Error Resume Next\r\n strCaption = fld.Properties("Caption")\r\n On Error GoTo 0\r\n WizHook.Key = 51488399\r\n WizHook.TwipsFromFont ctl.FontName, ctl.FontSize, ctl.FontWeight, ctl.FontItalic, _\r\n ctl.FontUnderline, 0, strCaption, 0, lngXTemp, lngYTemp\r\n If lngXTemp > lngX Then\r\n lngX = lngXTemp\r\n End If\r\n If lngYTemp > lngY Then\r\n lngY = lngYTemp\r\n End If\r\n Next fld\r\nEnd Function<\/pre>\nPublic Function GetMaximalSizeControl(db As DAO.Database, strRecordsource As String, _\r\n ByVal ctl As Control, fld As DAO.Field, lngDXMax As Long, lngDYMax As Long)\r\n ''...Deklaration\r\n lngDXMax = 0\r\n lngDYMax = 0\r\n intControlType = ctl.ControlType\r\n Select Case intControlType\r\n Case acCheckBox\r\n Set ctl = CreateControl(ctl.Parent.Name, acTextBox, acDetail)\r\n End Select\r\n On Error Resume Next\r\n intControlType = fld.Properties("DisplayControl")\r\n On Error GoTo 0\r\n Select Case intControlType\r\n Case acComboBox, acListBox\r\n Set rst = db.OpenRecordset(fld.Properties("RowSource"))\r\n strSpaltenbreiten = Split(fld.Properties("ColumnWidths"), ";")\r\n For i = LBound(strSpaltenbreiten) To UBound(strSpaltenbreiten)\r\n If Not strSpaltenbreiten(i) = 0 Then\r\n varFeldname = i\r\n Exit For\r\n End If\r\n Next i\r\n Case Else\r\n Set rst = db.OpenRecordset(strRecordsource)\r\n varFeldname = fld.Name\r\n End Select\r\n Do While Not rst.EOF\r\n If IsNumeric(varFeldname) Then\r\n strText = Nz(rst.Fields(CInt(varFeldname)).Value)\r\n Else\r\n strText = Nz(rst.Fields(varFeldname).Value)\r\n End If\r\n WizHook.Key = 51488399\r\n WizHook.TwipsFromFont ctl.FontName, ctl.FontSize, ctl.FontWeight, ctl.FontItalic, _\r\n ctl.FontUnderline, 0, strText, 0, lngDX, lngDY\r\n If lngDX > lngDXMax Then\r\n lngDXMax = lngDX\r\n End If\r\n If lngDY > lngDYMax Then\r\n lngDYMax = lngDY\r\n End If\r\n rst.MoveNext\r\n Loop\r\n Select Case intControlType\r\n Case acComboBox\r\n lngDXMax = lngDXMax + lngDYMax\r\n Case acListBox\r\n lngDXMax = lngDXMax + lngDYMax\r\n lngDYMax = lngDYMax * 8\r\n Case acCheckBox\r\n DeleteControl ctl.Parent.Name, ctl.Name\r\n End Select\r\n lngDXMax = (lngDXMax + 100) * 1.3\r\n lngDYMax = lngDYMax * 1.1\r\nEnd Function<\/pre>\nPublic Function BuildLabel(frm As Form, fld As DAO.Field, ctl As Control, intControlType As _\r\n AcControlType, lngLabelX As Long, lngLabelY As Long, sngTop As Single) As Label\r\n Dim lbl As Control\r\n Dim strCaption As String\r\n Set lbl = Application.CreateControl(frm.Name, acLabel, acDetail, ctl.Name, , 100, sngTop, _\r\n lngLabelX + 100, lngLabelY)\r\n strCaption = fld.Name\r\n On Error Resume Next\r\n strCaption = fld.Properties("Caption")\r\n On Error GoTo 0\r\n If frm.DefaultControl(intControlType).AddColon Then\r\n strCaption = strCaption & ":"\r\n End If\r\n lbl.Caption = strCaption\r\n Set BuildLabel = lbl\r\nEnd Function<\/pre>\n