<\/p>\n
Im Beitrag „Formulare per VBA erstellen“ (www.access-im-unternehmen.de\/1332) haben wir gezeigt, wie Sie per VBA ein neues, leeres Formular erstellen und seine Eigenschaften einstellen. Darauf wollen wir in diesem Beitrag aufbauen und zeigen, wie Sie dem Formular per VBA die gewünschten Steuerelemente hinzufügen können. Und auch Steuerelemente haben eine Menge Eigenschaften, die wir nach dem Anlegen einstellen müssen – Position, Aussehen und auch wieder Ereigniseigenschaften. Nach der Lektüre des vorliegenden Beitrags haben Sie alle Werkzeuge, die Sie brauchen, um beispielsweise Access-Add-Ins zu nutzen, um einer Anwendung neue Formulare und Steuerelemente hinzuzufügen.<\/b><\/p>\nVorbereitung: Formular anlegen<\/h2>\n
Als Vorbereitung wollen wir mit den Techniken, die wir im oben genannten Beitrag zum Erstellen von Formularen gelernt haben, zunächst ein neues Formular erzeugen. Dazu verwenden wir eine Funktion, die weitere Funktionen aus dem oben genannten Beitrag nutzt.<\/p>\n
Die folgende Funktion erwartet den Namen des zu erstellenden Formulars und übergibt diesen an eine weitere Funktion namens CreateNewForm<\/b>. Liefert diese den Wert True <\/b>zurück, wurde das Formular erfolgreich erstellt.<\/p>\n
Dann öffnen wir dieses Formular in der Formularansicht und stellen noch die Anzeige von Kopf- und Fußbereich ein – diese Bereiche werden wir weiter unten nämlich auch mit Steuerelementen versehen. Schließlich gibt die Funktion einen Verweis auf das noch in der Entwurfsansicht geöffnete Form<\/b>-Objekt zurück:<\/p>\n Diese Funktion rufen wir von der folgenden Prozedur aus auf und referenzieren das erstellte und geöffnete Formular mit der Variablen frm<\/b>:<\/p>\n Danach können wir bereits loslegen, indem wir die gewünschten Anweisungen an Stelle des Kommentars “Steuerelemente anlegen <\/b>einfügen! Die minimale Version der Methode CreateControl <\/b>hat nur zwei Parameter – den Namen des Formulars und den Typ des Steuerelements, hier acTextBox <\/b>für ein Textfeld:<\/p>\n Dieser Befehl legt bereits ein einfaches Steuerelement an, wobei die Position links oben im Detailbereich des Formulars ist.<\/p>\n Wichtig ist, dass Sie genau wie über die Benutzeroberfläche nur Steuerelemente anlegen können, wenn das Formular in der Entwurfsansicht geöffnet ist.<\/p>\n Die Methode CreateControl<\/b>, eigentlich ein Teil des Application<\/b>-Objekts, aber auch ohne dessen Angabe aufrufbar, hat noch weitere Parameter. Nur die ersten beiden Parameter FormName <\/b>und ControlType <\/b>sind Pflichtparameter:<\/p>\n Um ein Textfeld mit einem Bezeichnungsfeld zu erstellen, benötigen Sie zwei Aufrufe der CreateControl<\/b>-Methode. Mit dem ersten erstellen Sie das Textfeld, mit dem zweiten das Bezeichnungsfeld.<\/p>\n Für das Bezeichnungsfeld stellen wir den Parameter Parent <\/b>auf das Textfeld ein. Auf diese Weise werden die beiden Steuerelemente so verknüpft, wie es auch beim Anlegen von Textfeldern über den Entwurf geschieht oder wenn Sie Felder aus der Feldliste in den Entwurf ziehen.<\/p>\n Für ein einfaches Textfeld mit einem Bezeichnungsfeld benötigen Sie die folgenden Anweisungen. Die Variablen txt <\/b>und lbl <\/b>dienen zum Referenzieren der neu erstellten Steuerelemente. Das Textfeld erstellen wir im Formular mit dem Namen, den wir mit frm.Name <\/b>für das mit frm <\/b>wie oben referenzierte Formular abfragen, als acTextBox <\/b>im Bereich acDetail<\/b>. Außerdem legen wir die Position mit 1400 Twips vom linken und 100 Twips vom oberen Rand und die Größe mit einer Breite von 2000 Twips und einer Höhe von 300 Twips fest:<\/p>\n Danach erstellen wir das Bezeichnungsfeld ebenfalls in frm.Name<\/b> als acLabel <\/b>im Bereich acDetail<\/b>. Es soll dem zuvor erstellten Textfeld untergeordnet werden, also geben wir für den Parameter Parent <\/b>den Namen des Textfeldes an (mit txt.Name<\/b>). txt.Name <\/b>funktioniert immer, auch wenn wir den Namen des Textfeldes nicht explizit festgelegt haben und liefert für das erste Textfeld im Formular beispielsweise den Wert Text0<\/b>.<\/p>\n Die Position und die Abmessungen definieren wir so, dass das Bezeichnungsfeld links vom Textfeld erscheint. Anschließend legen wir noch die Beschriftung fest, indem wir die Eigenschaft Caption <\/b>für das zuvor definierte und mit der Variablen lbl <\/b>referenzierte Bezeichnungsfeld auf den Wert Textfeld: <\/b>festlegen:<\/p>\n Indem Sie das Bezeichnungsfeld mit dem Parent<\/b>-Parameter an das Textfeld binden, sorgen Sie gleichzeitig dafür, dass die Eigenschaft Bezeichnungsname <\/b>des Textfeldes auf den Namen des Bezeichnungsfeldes eingestellt wird.<\/p>\n Das Ergebnis finden Sie in Bild 1 (siehe Prozedur FormularMitTextfeldUndBezeichnungsfeld<\/b>).<\/p>\n Bild 1: Textfeld mit Bezeichnungsfeld<\/span><\/b><\/p>\n Nun gehen wir einen Schritt weiter und wollen zwei gebundenen Textfelder anlegen. Dazu stellen wir als Erstes die Eigenschaft Recordsource <\/b>(Datensatzquelle<\/b>) des Formulars auf die Tabelle tblArtikel <\/b>ein:<\/p>\n Danach erstellen wir nacheinander zwei Textfelder mit Bezeichnungsfeldern, wobei wir im Gegensatz zum vorherigen Beispiel nun den Parameter ColumnName <\/b>nutzen, um das Feld anzugeben, an welches das jeweilige Textfeld gebunden werden soll:<\/p>\n Das so erstellte Formular sieht in der Formularansicht wie in Bild 2 aus (siehe Prozedur GebundeneTextfelder<\/b>).<\/p>\n Bild 2: Formular mit gebundenen Textfeldern<\/span><\/b><\/p>\n Wenn wir die Tabelle tblArtikel <\/b>betrachten, finden wir als Nächstes zwei Nachschlagefelder.<\/p>\n Diese wollen wir nun in Form von Kombinationsfeldern zum Formular hinzufügen. Für das erste Nachschlagefeld namens KategorieID <\/b>sieht der dazu nötige Code wie folgt aus:<\/p>\n Wie wir in Bild 3 sehen, brauchen wir nur das zugrunde liegende Nachschlagefeld der Tabelle mit dem Parameter Column-Name <\/b>anzugeben, damit ein neues Kombinationsfeld mit allen in der Tabelle für dieses Feld festgelegten Eigenschaften erstellt wird (siehe Prozedur GebundeneKombinationsfelder<\/b>).<\/p>\n Bild 3: Formular mit gebundenem Kombinationsfeld<\/span><\/b><\/p>\n Wenn Sie mit dem Parameter ColumnName <\/b>ein Feld der zugrunde liegenden Datensatzquelle angeben, stellt dies nicht nur die Eigenschaft Steuerelementinhalt <\/b>auf den Namen des zu bindenden Feldes ein. Dazu gehören Eigenschaften wie Textformat<\/b>, Eingabeformat<\/b>, Standardwert<\/b>, Gültigkeitsregel <\/b>oder Gültigkeitsmeldung<\/b>. Bei Kombinationsfeldern auf Basis von Nachschlagefeldern werden, wir oben gezeigt, sogar die Eigenschaften des Nachschlagefeldes übernommen.<\/p>\n Ein oft erledigter Schritt ist das Erstellen eines Detailformulars, also ein Formular, das die Daten einer Tabelle oder Abfrage anzeigen soll. Dazu sind normalerweise einige Schritte nötig wie das Erstellen des Formulars, das Hinzufügen der Datensatzquelle, das Hineinziehen der Felder in den Formularentwurf und gegebenenfalls noch das Anordnen der Felder, weil Access beim Hineinziehen von Feldern aus der Feldliste beispielsweise Kontrollkästchen immer links vom Bezeichnungsfeld anordnet und die übrigen Steuerelemente immer rechts vom Bezeichnungsfeld.<\/p>\n Deshalb zeigen wir im Folgenden eine praktische Anwendung der Techniken, die Sie weiter oben gelernt haben.<\/p>\n Die Prozedur DetailformularErstellen <\/b>erwartet drei Parameter:<\/p>\n Die Prozedur, deren Code Sie in Listing 1 finden, schließt zunächst eine gegebenenfalls noch geöffnete Instanz des Formulars mit dem in strForm <\/b>übergebenen Namen. Dann erstellt sie dieses mit der Funktion GetNewForm <\/b>unter dem angegebenen Namen neu und referenziert das neu erstellte und in der Entwurfsansicht geöffnete Formular mit der Variablen frm<\/b>.<\/p>\n Listing 1: Prozedur zum Erstellen eines Detailformulars<\/span><\/b><\/p>\n Die einzige Formulareigenschaft, welche die Prozedur einstellt, ist RecordSource<\/b>. Sie erhält den Wert aus strRecordsource<\/b>.<\/p>\n Danach referenziert die Prozedur mit db <\/b>das aktuelle Database<\/b>-Objekt und mit rst <\/b>ein Recordset auf Basis der mit strRecordsource <\/b>übergebenen Datensatzquelle, bei der es sich um eine Tabelle, Abfrage oder auch einen SQL-Ausdruck handeln kann. Anschließend durchläuft sie in einer For Each<\/b>-Schleife alle Felder der Fields<\/b>-Auflistung des Recordsets.<\/p>\n In dieser Schleife stellt die Prozedur zunächst die beiden Variablen intDisplayControl <\/b>und strCaption<\/b> auf die Werte 0 <\/b>beziehungsweise eine leere Zeichenkette ein. intDisplayControl <\/b>soll später den Steuerelementtyp aufnehmen, der für die Anzeige des Feldes in der Datenblattansicht definiert wurde. Dieser Steuerelementtyp wird beim Entwerfen einer Tabelle automatisch von Access vorgegeben – bei Feldern des Datentyps Kurzer Text <\/b>zum Beispiel Textfeld, bei Nachschlagefeldern Kombinationsfeld oder bei Ja\/Nein<\/b>-Feldern Kontrollkästchen.<\/p>\n Bei reinen Zahlenfeldern wird kein Steuerelement voreingestellt. Bild 4 zeigt, wo Sie die Eigenschaft DisplayControl <\/b>beziehungsweise Steuerelement anzeigen <\/b>im Entwurf der Tabelle einsehen können. DisplayControl <\/b>liefert Werte einer Enumeration wie acTextBox<\/b>, acComboBox <\/b>oder acCheckBox<\/b>.<\/p>\n <\/p>\n Bild 4: Wert der Eigenschaft DisplayControl<\/span><\/b><\/p>\n Die Variable strCaption <\/b>soll den Wert der Eigenschaft Beschriftung <\/b>aufnehmen oder, wenn keine Beschriftung angelegt wurde, den Feldnamen. Die Eigenschaft Beschriftung<\/b> heißt unter VBA Caption<\/b>. Sie können diese auf der Registerseite Allgemein <\/b>des oben referenzierten Screenshots festlegen, diese Beschriftung wird dann als Spaltenüberschrift oder auch als Label-Beschriftung beim Ziehen von Feldern aus der Feldliste verwendet.<\/p>\n Warum setzen wir die beiden Variablen intDisplayControl <\/b>und strCaption<\/b> immer wieder auf 0 <\/b>und „“<\/b> Weil die Properties DisplayControl <\/b>und Caption<\/b>, mit denen wir diese füllen wollen, nicht immer vorhanden sind und wir versuchen, diese unter Deaktivierung der Fehlerbehandlung aus den Properties abzufragen. Da wir dies innerhalb einer Schleife machen, würden die Variablen, wenn sie nicht aus den Properties gefüllt werden können, gegebenenfalls noch den Wert aus dem vorherigen Durchgang enthalten, wenn wir sie nicht leeren.<\/p>\n Die Werte der Eigenschaften DisplayControl <\/b>und Caption <\/b>fragen wir also bei deaktivierter Fehlerbehandlung über die Auflistung Properties <\/b>ab und speichern diese in intDisplayControl <\/b>und strCaption<\/b>. War die Property Caption <\/b>nicht vorhanden, ist strCaption <\/b>danach leer und wir füllen es ersatzweise mit dem Namen des Feldes.<\/p>\n intDisplayControl <\/b>nimmt einen der Werte acCheckbox<\/b>, acComboBox<\/b>, acTextBox <\/b>oder 0 <\/b>an. Diesen prüfen wir in der folgenden Select Case<\/b>-Bedingung. Im Falle von acCheckBox <\/b>erstellt die Prozedur mit der CreateControl<\/b>-Methode ein neues Steuerelement des Typs acCheckbox <\/b>im Detailbereich des Formulars. Das Feld wird an den mit fld.Name <\/b>gelieferten Feldnamen gebunden.<\/p>\n Die Breite ermitteln wir aus dem Parameter lngCaptionWidth <\/b>plus 200<\/b>, damit wir 200 Twips Abstand zwischen Label und Steuerelement erhalten. Den Abstand von oben stellen wir über den Wert der Variablen lngTop <\/b>plus 100 <\/b>ein. lngTop<\/b> erhöhen wir nach jedem Steuerelement um 400<\/b>, damit das nächste Steuerelement um 400 Twips weiter unten angeordnet wird. Im Falle von acCheckBox <\/b>brauchen wir Höhe und Breite nicht anzugeben, da die CheckBox<\/b> immer gleich groß ist.<\/p>\n Anschließend weisen wir dem mit chk <\/b>referenzierten neuen CheckBox<\/b>-Steuerelement über die Eigenschaft Name <\/b>den Namen des Feldes plus Präfix chk <\/b>zu. Das folgende Label<\/b>-Steuerelement legen wir links vom CheckBox<\/b>-Steuerelement an. Weiter unten, außerhalb der Select Case<\/b>-Bedingung, stellen wir noch seine Eigenschaft Caption <\/b>auf den Wert aus strCaption <\/b>ein.<\/p>\n Auf ähnliche Weise verfahren wir mit den Feldern, die für die Eigenschaft DisplayControl <\/b>die Werte acComboBox <\/b>oder acTextBox <\/b>hinterlegt haben. Der Unterschied ist, dass wir diese Variablen des jeweiligen Typs zuweisen (ComboBox <\/b>und TextBox<\/b>) und dass wir für diese noch die Breite und die Höhe auf die Werte 2000 <\/b>und 300 <\/b>einstellen.<\/p>\n Schließlich weisen wir auch diesen Steuerelementen als Name ein Präfix wie cbo <\/b>oder txt <\/b>plus dem Feldnamen zu und erstellen die entsprechenden Label<\/b>-Steuerelemente links neben dem Kombinations- oder Textfeld.<\/p>\n Die letzte Bedingung prüft übrigens nicht auf den Wert acTextBox<\/b>, sondern verarbeitet alle übrigen Werte. Der Hintergrund ist, dass wir es ja nicht unbedingt mit acTextBox <\/b>zu tun haben, sondern dass bei dem Steuerelement die Eigenschaft DisplayControl <\/b>nicht definiert ist – dann soll dieses auch als TextBox<\/b>-Steuerelement realisiert werden.<\/p>\n Nach dem Verlassen der Select Case<\/b>-Bedingung stellen wir noch die Eigenschaft Caption <\/b>des Label<\/b>-Steuerelements aus lbl <\/b>ein und erhöhen den Wert von lngTop <\/b>um 400<\/b>, damit das folgende Steuerelement unter dem aktuellen Steuerelement angelegt wird.<\/p>\n Den Aufruf gestalten wir beispielsweise wie folgt:<\/p>\n Das Ergebnis finden Sie in Bild 5.<\/p>\n Bild 5: Entwurf des per Code erstellten Formulars zur Anzeige von Artikeln in der Detailansicht<\/span><\/b><\/p>\n Hier sehen wir noch einen kleinen Makel, denn die Beschriftungen werden nicht mit einem Doppelpunkt abgeschlossen. Wenn Sie das wünschen, können Sie es auf zwei Arten erledigen:<\/p>\n Die letztere Variante wäre sinnvoller, denn es kann auch sein, dass bei Ihnen die Doppelpunkte automatisch hinzugefügt werden. Dies hängt von der Einstellung der Eigenschaft Mit Doppelpunkt <\/b>der jeweiligen Standardsteuerelemente ab. Diese Eigenschaft sehen Sie bei bereits hinzugefügten Steuerelementen nicht, sondern nur, wenn Sie im Ribbon auf das jeweilige Steuerelement klicken – beispielsweise auf das Textfeld<\/b>-Steuerelement -, ohne das Steuerelement tatsächlich zum Entwurf des Formulars hinzuzufügen und dann im Eigenschaftenblatt auf der Registerseite Format unten die Eigenschaft Mit Doppelpunkt <\/b>betrachten (siehe Bild 6).<\/p>\n Bild 6: Einstellen der Eigenschaften für das Standardsteuerelement, hier für ein Textfeld.<\/span><\/b><\/p>\n Aber selbst wenn wir diese Eigenschaft wie folgt per VBA zu Beginn der Prozedur beispielsweise für die Textfelder dieses Formulars einstellen und den Formularentwurf anschließend speichern, führt dies nicht dazu, dass die Label anschließend automatisch mit abschließenden Doppelpunkten versehen werden. Das Standardsteuerelement für die Textbox erhalten Sie beispielsweise mit frm.DefaultControl(acTextBox) <\/b>und weisen wie folgt den Wert True <\/b>der Eigenschaft AddColon <\/b>beziehungsweise Mit Doppelpunkt <\/b>hinzu:<\/p>\n Es scheint also unabhängig davon zu sein, ob die Eigenschaft AddColon <\/b>aktiviert ist oder nicht – wenn wir die Label<\/b>-Steuerelemente separat hinzufügen, was per VBA nicht anders möglich ist, können wir die Doppelpunkte per VBA hinzufügen. Offensichtlich werden Doppelpunkte auch bei aktivierter Eigenschaft Mit Doppelpunkt <\/b>für das Standardsteuerelement nur angelegt, wenn Sie das Textfeld über die Benutzeroberfläche hinzufügen oder durch das Ziehen von Feldern aus der Feldliste.<\/p>\n Also passen wir die Prozedur schlicht so an, dass die Doppelpunkte immer hinzugefügt werden:<\/p>\n Danach erhalten wir die Beschriftungen mit Doppelpunkten.<\/p>\n Auf ähnliche Weise können Sie ein Formular erstellen, das standardmäßig in der Datenblattansicht angezeigt wird. Dazu müssen Sie zu der zuvor beschriebenen Prozedur lediglich die Zuweisung einer Eigenschaft hinzufügen, mit der wir die Standardansicht auf Datenblatt einstellen:<\/p>\n Sie erhalten dann genau das gleiche Ergebnis, allerdings in der Datenblattansicht. Die einzigen Elemente, die wir wegnehmen könnten, sind die Angaben der Position der Steuerelemente – alle anderen werden auch im Formular in der Datenblattansicht benötigt.<\/p>\n Allerdings wollen Sie vielleicht später manuelle Änderungen am Entwurf vornehmen, was schwierig wird, wenn alle Elemente übereinander angelegt wurden.<\/p>\n Die Prozedur für diesen Zweck heißt Datenblattformular-Erstellen<\/b> und kann beispielsweise wie folgt aufgerufen werden:<\/p>\n Damit erstellen wir ein Formular in der Datenblattansicht, das wir prima für das folgende Beispiel nutzen können.<\/p>\n Wenn Sie einem Formular ein Unterformular-Steuerelement hinzufügen möchten und in diesem ein Unterformular anzeigen wollen, müssen Sie zwei Formulare erstellen – eines als Haupt- und eines als Unterformular. Das Unterformular zeigt seine Daten normalerweise in der Datenblattansicht an, während das Hauptformular in der Formularansicht erscheint. Also können wir als Unterformular prima ein mit der Prozedur Datenblattformular-Erstellen <\/b>angelegtes Formular nutzen. Daher bauen wir diese Prozedur in die nachfolgend vorgestellte Prozedur FormularMitUnterformular <\/b>ein (siehe Listing 2).<\/p>\n Listing 2: Prozedur zum Erstellen eines Formulars mit Unterformular<\/span><\/b><\/p>\n Diese Prozedur haben wir auch gleich mit Parametern versehen:<\/p>\n Die Prozedur schließt zunächst ein gegebenenfalls noch geöffnetes Formular mit dem Namen aus strForm<\/b> und erstellt dieses dann mit der Prozedur GetNewForm <\/b>neu. Dann erstellt sie mit der zuvor beschriebenen Prozedur DatenblattformularErstellen <\/b>das Unterformular, wobei sie die beiden Parameter strSubform <\/b>und strRecordsource <\/b>an diese Prozedur übergibt. Anschließend schließt sie dieses frisch erstellte Unterformular.<\/p>\n Für das mit frm <\/b>referenzierte Hauptformular stellt die Prozedur dann die Eigenschaften DividingLines <\/b>(Trennlinien<\/b>), NavigationButtons <\/b>(Navigationsschaltflächen<\/b>), RecordSelectors <\/b>(Datensatzmarkierer<\/b>) und ScrollBars <\/b>(Bildlaufleisten<\/b>) auf False <\/b>ein sowie die Eigenschaft AutoCenter <\/b>(Automatisch zentrieren<\/b>) auf True<\/b>.<\/p>\n Anschließend erstellt sie mit der CreateControl<\/b>-Methode ein neues Unterformular-Steuerelement. Dabei verwenden wir den Namen aus strForm<\/b>, den Typ acSubform <\/b>und als Zielbereich acDetail<\/b>. Den Abstand vom linken und oberen Rand sowie die Höhe und die Breite stellen wir diesmal so ein, dass das Unterformular-Steuerelement von allen Rändern einen Abstand von 100 Twips hat. Für den Abstand vom linken und oberen Rand ist das einfach, aber für den gleichen Abstand vom rechten und unteren Rand müssen wir die Werte für die Parameter Width <\/b>und Height <\/b>noch berechnen.<\/p>\n Bei der Breite ist es einfach: Wir nehmen einfach die Breite des Formulars (frm.Width<\/b>) und ziehen dort 200 Twips ab – jeweils 100 für den Abstand vom linken und vom rechten Rand. Für die Höhe können wir nicht einfach die Eigenschaft Height <\/b>des Form<\/b>-Elements nehmen – die gibt es schlichtweg nicht.<\/p>\n Hier benötigen wir die Höhe des Bereichs, in dem wir das Unterformular-Steuerelement einfügen wollen. Diesen referenzieren wir mit frm.Section(acDetail) <\/b>und erhalten die Höhe mit der Height<\/b>-Eigenschaft dieses Bereichs.<\/p>\n Anschließend weist die Prozedur dem Unterformular-Steuerelement den Namen sfm <\/b>zu und stellt die beiden Eigenschaften HorizontalAnchor <\/b>(Horizontaler Anker<\/b>) und VerticalAnchor <\/b>(Vertikaler Anker<\/b>) auf die Werte acHorizontalAnchorBoth <\/b>und acVerticalAnchorBoth <\/b>ein.<\/p>\n Die wichtigste Einstellung ist jedoch die Eigenschaft SourceObject <\/b>des Unterformular-Steuerelements. Diesem weisen wir den Namen des als Unterformular anzuzeigenden Formulars zu. Schließlich öffnet die Prozedur das neu erstellte Formular in der Formularansicht.<\/p>\n In der Entwurfsansicht sieht das Ergebnis wie in Bild 7 aus.<\/p>\n Bild 7: Entwurf des Formulars mit Unterformular<\/span><\/b><\/p>\n Damit gehen wir noch einen Schritt weiter, indem wir das Hauptformular auch noch an eine Tabelle binden und dessen Daten im Hauptformular anzeigen. Die Tabellen der Daten im Haupt- und im Unterformular sollen in einer 1:n-Beziehung stehen und wir wollen dafür sorgen, dass das Unterformular nur die zu dem aktuell im Hauptformular angezeigten Datensatz passen.<\/p>\n Als Beispiel verwenden wir für das Hauptformular die Tabelle tblKategorien <\/b>und für das Unterformular die Tabelle tlbArtikel<\/b>.<\/p>\n Diese Prozedur funktioniert übrigens nur, wenn sowohl das Hauptformular als auch das Unterformular Tabellen als Datensatzquellen verwenden – mit Abfragen oder SQL-Ausdrücken funktioniert es nicht. Die Erklärung dafür finden Sie weiter unten.<\/p>\n Die Prozedur FormularMitUnterformular_1n <\/b>finden Sie in Listing 3. Sie erwartet vier Parameter:<\/p>\nPublic Function <\/span>GetNewForm(strForm As String<\/span>) As <\/span>Form\r\n Dim <\/span>frm As <\/span>Form\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 RunCommand acCmdFormHdrFtr\r\n .Section(acHeader).Visible = True<\/span>\r\n .Section(acFooter).Visible = True<\/span>\r\n End With<\/span>\r\n End If<\/span>\r\n Set<\/span> GetNewForm = frm\r\nEnd Function<\/span><\/pre>\nSteuerelemente anlegen per VBA<\/h2>\n
Public Sub <\/span>SteuerelementeAnlegen()\r\n Dim <\/span>frm As <\/span>Form\r\n Set<\/span> frm = GetNewForm(\"frmMitSteuerelementen\")\r\n ''Steuerelemente anlegen\r\nEnd Sub<\/span><\/pre>\nCreateControl frm.Name, acTextBox<\/pre>\n
Die Methode CreateControl<\/h2>\n
\n
Textfeld mit Bezeichnungsfeld anlegen<\/h2>\n
Dim <\/span>txt As <\/span>TextBox\r\nDim <\/span>lbl As <\/span>Label\r\nSet<\/span> txt = CreateControl(frm.Name, acTextBox, acDetail, , , 1400, 100, 2000, 300)<\/pre>\nSet<\/span> lbl = CreateControl(frm.Name, acLabel, acDetail, txt.Name, , 100, 100, 1200, 300)\r\nlbl.Caption = \"Textfeld:\"<\/pre>\n![\"Textfeld](\"..\/fileadmin\/_temp_\/2022_02\/pic_1336_001.png\")
<\/p>\nGebundene Textfelder anlegen<\/h2>\n
frm.RecordSource = \"tblArtikel\"<\/pre>\n
Dim <\/span>txt As <\/span>TextBox\r\nDim <\/span>lbl As <\/span>Label\r\nSet<\/span> txt = CreateControl(frm.Name, acTextBox, acDetail, , \"ArtikelID\", 1500, 100, 2000, 300)\r\nSet<\/span> lbl = CreateControl(frm.Name, acLabel, acDetail, txt.Name, , 100, 100, 1300, 300)\r\nlbl.Caption = \"ArtikelID:\"\r\nSet<\/span> txt = CreateControl(frm.Name, acTextBox, acDetail, , \"Artikelname\", 1500, 500, 2000, 300)\r\nSet<\/span> lbl = CreateControl(frm.Name, acLabel, acDetail, txt.Name, , 100, 500, 1300, 300)\r\nlbl.Caption = \"Artikelname:\"<\/pre>\n![\"Formular](\"..\/fileadmin\/_temp_\/2022_02\/pic_1336_002.png\")
<\/p>\nGebundene Kombinationsfelder anlegen<\/h2>\n
Dim <\/span>cbo As <\/span>ComboBox\r\n...\r\nSet<\/span> cbo = CreateControl(frm.Name, acComboBox, acDetail, , \"KategorieID\", 1500, 900, 2000, 300)\r\nSet<\/span> lbl = CreateControl(frm.Name, acLabel, acDetail, cbo.Name, , 100, 900, 1300, 300)\r\nlbl.Caption = \"KategorieID:\"<\/pre>\n![\"Formular](\"..\/fileadmin\/_temp_\/2022_02\/pic_1336_003.png\")
<\/p>\nÜbernahme von Eigenschaften bei gebundenen Steuerelementen<\/h2>\n
Detailformular erstellen<\/h2>\n
\n
Public Sub <\/span>DetailformularErstellen(strForm As String<\/span>, strRecordsource As String<\/span>, Optional<\/span> lngCaptionWidth As Long<\/span> = 1500)\r\n Dim <\/span>frm As <\/span>Form\r\n Dim <\/span>db As <\/span>DAO.Database\r\n Dim <\/span>rst As <\/span>DAO.Recordset\r\n Dim <\/span>fld As <\/span>DAO.Field\r\n Dim <\/span>strDisplayControl As String<\/span>\r\n Dim <\/span>strCaption As String<\/span>\r\n Dim <\/span>txt As <\/span>TextBox\r\n Dim <\/span>lbl As <\/span>Label\r\n Dim <\/span>cbo As <\/span>ComboBox\r\n Dim <\/span>chk As <\/span>CheckBox\r\n Dim <\/span>lngTop As Long<\/span>\r\n DoCmd.Close acForm, strForm\r\n Set<\/span> frm = GetNewForm(strForm)\r\n frm.RecordSource = strRecordsource\r\n Set<\/span> db = CurrentDb\r\n Set<\/span> rst = db.OpenRecordset(strRecordsource)\r\n For Each fld In rst.Fields\r\n strDisplayControl = 0\r\n strCaption = \"\"\r\n On Error Resume Next<\/span>\r\n intDisplayControl = fld.Properties(\"DisplayControl\")\r\n strCaption = fld.Properties(\"Caption\")\r\n On Error GoTo<\/span> 0\r\n If <\/span>Len<\/span>(strCaption) = 0 Then<\/span>\r\n strCaption = fld.Name\r\n End If<\/span>\r\n Select Case intDisplayControl\r\n Case <\/span>acCheckBox\r\n Set<\/span> chk = CreateControl(frm.Name, acCheckBox, acDetail, , fld.Name, lngCaptionWidth + 200, lngTop + 100)\r\n chk.Name = \"chk\" & fld.Name\r\n Set<\/span> lbl = CreateControl(frm.Name, acLabel, acDetail, chk.Name, , 100, lngTop + 100, lngCaptionWidth, 300)\r\n Case <\/span>acComboBox\r\n Set<\/span> cbo = CreateControl(frm.Name, acComboBox, acDetail, , fld.Name, lngCaptionWidth + 200, _\r\n lngTop + 100, 2000, 300)\r\n cbo.Name = \"cbo\" & fld.Name\r\n Set<\/span> lbl = CreateControl(frm.Name, acLabel, acDetail, cbo.Name, , 100, lngTop + 100, lngCaptionWidth, 300)\r\n Case Else<\/span>\r\n Set<\/span> txt = CreateControl(frm.Name, acTextBox, acDetail, , fld.Name, lngCaptionWidth + 200, _\r\n lngTop + 100, 2000, 300)\r\n txt.Name = \"txt\" & fld.Name\r\n Set<\/span> lbl = CreateControl(frm.Name, acLabel, acDetail, txt.Name, , 100, lngTop + 100, lngCaptionWidth, 300)\r\n End Select<\/span>\r\n lbl.Caption = strCaption\r\n lngTop = lngTop + 400\r\n Next<\/span> fld\r\nEnd Sub<\/span><\/pre>\n![\"Wert](\"..\/fileadmin\/_temp_\/2022_02\/pic_1336_004.png\")
<\/p>\nDetailformularErstellen \"frmArtikelDetail\", \"tblArtikel\", 2000<\/pre>\n
![\"Entwurf](\"..\/fileadmin\/_temp_\/2022_02\/pic_1336_005.png\")
<\/p>\nDoppelpunkte sicherstellen<\/h2>\n
\n
![\"Einstellen](\"..\/fileadmin\/_temp_\/2022_02\/pic_1336_006.png\")
<\/p>\nSet<\/span> txt = frm.DefaultControl(acTextBox)\r\ntxt.AddColon = True<\/span>\r\nDoCmd.Save acForm, frm.Name<\/pre>\nlbl.Caption = strCaption & \":\"<\/pre>\n
Formular in der Datenblattansicht erstellen<\/h2>\n
frm.DefaultView = acDefViewDatasheet<\/pre>\n
DatenblattformularErstellen \"sfmArtikelUebersicht\", \"tblArtikel\", 2000<\/pre>\n
Unterformular hinzufügen<\/h2>\n
Public Sub <\/span>FormularMitUnterformular(strForm As String<\/span>, strSubform As String<\/span>, strRecordsource As String<\/span>)\r\n Dim <\/span>frm As <\/span>Form\r\n Dim <\/span>sfm As <\/span>SubForm\r\n DoCmd.Close acForm, strForm\r\n Set<\/span> frm = GetNewForm(strForm)\r\n DatenblattformularErstellen strSubform, strRecordsource, 2000\r\n DoCmd.Close acForm, strSubform, acSaveYes\r\n frm.DividingLines = False<\/span>\r\n frm.NavigationButtons = False<\/span>\r\n frm.RecordSelectors = False<\/span>\r\n frm.ScrollBars = False<\/span>\r\n frm.AutoCenter = True<\/span>\r\n Set<\/span> sfm = CreateControl(strForm, acSubform, acDetail, , , 100, 100, frm.Width - 200, frm.Section(0).Height - 200)\r\n sfm.Name = \"sfm\"\r\n sfm.HorizontalAnchor = acHorizontalAnchorBoth\r\n sfm.VerticalAnchor = acVerticalAnchorBoth\r\n sfm.SourceObject = strSubform\r\n DoCmd.OpenForm strForm\r\nEnd Sub<\/span><\/pre>\n\n
![\"Entwurf](\"..\/fileadmin\/_temp_\/2022_02\/pic_1336_007.png\")
<\/p>\nFormular und Unterformular mit 1:n-Beziehung erstellen<\/h2>\n
Public Sub <\/span>FormularMitUnterformular_1n(strForm As String<\/span>, strSubform As String<\/span>, strRecordsourceForm As String<\/span>, _\r\n strRecordsourceSubform As String<\/span>)\r\n Dim <\/span>frm As <\/span>Form\r\n Dim <\/span>sfm As <\/span>SubForm\r\n Dim <\/span>lngTop As Long<\/span>\r\n Dim <\/span>ctlBottom As <\/span>Control\r\n Dim <\/span>strLinkChildFields As String<\/span>\r\n