<\/p>\n
Bei der Arbeit mit Microsoft Access gibt es immer wiederkehrende Aufgaben – zum Beispiel das Anlegen von Detailformularen. Diese sollen die Daten aus einfachen Tabellen darstellen und zwei Schaltflächen namens OK und Abbrechen bereitstellen. So kann der Benutzer neue oder geänderte Datensätze übernehmen oder diese verwerfen. Dazu sind immer wieder viele kleine Handgriffe nötig. Damit dies ab jetzt schneller geht, schauen wir uns an, wie wir die meisten der Schritte automatisieren können. Dazu bauen wir ein Formular, mit dem wir alle Konfigurationsschritte erledigen können – von der Auswahl der Datenquelle über die Benennung des Formulars bis hin zur Erstellung des vollständigen Formulars inklusive Code.<\/b><\/p>\n
Viele Formulare sind eigentlich immer gleich aufgebaut. Für die herkömmliche Bearbeitung von Daten benötigt man ein Detailformular, das die Felder eines Datensatzes anzeigt und zwei Schaltflächen bietet, mit denen der Benutzer die eingegebenen Daten übernehmen oder verwerfen kann. <\/p>\n
Im Artikel Tabellendaten mit Übersicht und Details anzeigen <\/b>(www.access-im-unternehmen.de\/1488<\/b>) zeigen wir, welche Handgriffe alle nötig sind, um ein solches Formular manuell zu erstellen.<\/p>\n
Im vorliegenden Beitrag stellen wir eine Lösung vor, mit der wir die Daten aus beliebigen Tabellen schnell in ein Formular umwandeln können.<\/p>\n
Ein Beispiel für eine Tabelle, auf deren Basis wir ein Formular erstellen wollen, sehen wir in Bild 1.<\/p>\n
![\"Beispieltabelle](\"..\/fileadmin\/_temp_\/2024_02\/pic_1490_001.png\")
<\/p>\n
Bild 1: Beispieltabelle tblMitglieder<\/span><\/b><\/p>\n Formulare und Tabellen zur Steuerung der Erstellung der Formulare<\/p>\n Wir wären nicht in Access, wenn wir nicht auch für das Erstellen von Formularen per Code die dazu benötigten Daten für die Konfiguration in Tabellen speichern und die Konfiguration in Formularen bearbeiten würden.<\/p>\n Aber welche Daten müssen wir hier überhaupt erfassen?<\/p>\n Allein die Einstellung dieser Eigenschaften erfordert ein technisch anspruchsvolles Formular. Aber zuerst schauen wir uns an, welche Tabellen wir zum Erfassen dieser Daten benötigen.<\/p>\n Damit wir möglichst nah am Endergebnis arbeiten können, müssen wir bereits im Tabellenentwurf ein wenig Vorarbeit leisten. Wenn ein Feldname nicht dem Text entspricht, der nachher als Beschriftung in der Datenblattansicht und im Detailformular verwendet werden soll, müssen wir den gewünschten Text für die Eigenschaft Beschriftung <\/b>für die jeweiligen Felder im Tabellenentwurf eintragen. Außerdem wollen wir für Fremdschlüsselfelder, auf deren Basis Datensätze aus anderen Tabellen ausgewählt werden sollen, direkt Nachschlagfelder definieren. Die damit festgelegten Eigenschaften können wir dann direkt in das zu erstellende Formular übernehmen, genau wie das auch beim Hinzufügen von Feldern aus der Feldliste in manuell erstellten Formularen gelingt.<\/p>\n Das von uns zum Erstellen von Detailformularen verwendete Formular sehen Sie in Bild 2. Es bietet die Möglichkeit, verschiedene Konfigurationen zu speichern – wir können also Formulare auf Basis unterschiedlicher Tabellen oder Abfragen definieren und diese immer wieder neu erstellen. Das Formular erlaubt die Eingabe des Namens des zu erstellenden Detailformulars, die Auswahl der Datensatzquelle, also einer Tabelle oder Abfrage, das Festlegen eines Formulartitels und die Angabe eines einheitlichen Abstandes. Dieser wird angewendet für den Abstand aller Steuerelemente von den Formularrändern und für den Abstand zwischen den Steuerelementen. Die Eigenschaft Anzahl Spalten <\/b>haben wir vorerst nur vorbereitet, sie erfüllt noch keinen Zweck.<\/p>\n Bild 2: Formular zum Konfigurieren neuer Detailformulare<\/span><\/b><\/p>\n Rechts sehen wir einige typische Formulareigenschaften wie Automatisch zentrieren<\/b>, Datensatzmarkierer<\/b>, Navigationsschaltflächen<\/b>, Bildlaufleisten <\/b>oder Zyklus<\/b>.<\/p>\n Darunter sehen wir zwei Bereiche, in denen wir die Eigenschaften für die beiden Schaltflächen OK <\/b>und Abbrechen <\/b>einstellen können. Hier geben wir an, ob die jeweilige Schaltfläche überhaupt angelegt werden soll. Dann legen wir fest, welchen Text diese anzeigen und welchen Code sie ausführen sollen. Schließlich können wir auch noch ein Icon auswählen und festlegen, ob die Funktion der OK<\/b>-Schaltfläche auch durch die Eingabetaste ausgelöst werden soll und die Funktion der Abbrechen<\/b>-Schaltfläche durch die Escape<\/b>-Taste.<\/p>\n Darunter sehen wir die Möglichkeit, einen Button-Style auszuwählen. Ein Klick auf die Schaltfläche rechts daneben zeigt den Dialog aus Bild 3 an. Hier können wir einige grundlegende Einstellungen für das Aussehen von Schaltflächen vornehmen.<\/p>\n Bild 3: Formular zum Einstellen einiger Schaltflächeneigenschaften<\/span><\/b><\/p>\n Die Einstellung der Schriftarten haben wir ein wenig rudimentärer gestaltet. Ein Klick auf die Schaltfläche Schrifteigenschaften … <\/b>öffnet ein Formular in der Entwurfsansicht, das schlicht ein Bezeichnungsfeld anzeigt. Für dieses können wir hier die gewünschten Eigenschaften wie Schriftart, Schriftgröße, Farbe et cetera einstellen. Nach dem Speichern und Schließen holt sich das Formular zum Erstellen neuer Detailformulare die Eigenschaften für die Schrift aus diesem Formular.<\/p>\n Schließlich sehen wir im Unterformular noch die Liste der Felder der zugrunde liegenden Datensatzquelle. Diese wird nach der Auswahl der Tabelle oder Abfrage automatisch aufgrund der Daten der Datensatzquelle gefüllt.<\/p>\n Wir können hier je Feld verschiedene Eigenschaften einstellen. Die erste lautet IgnoreField <\/b>und erlaubt es, ein Feld durch das Setzen eines Hakens aus dem zu erstellenden Formular auszuschließen. Fieldlabel<\/b> nimmt entweder, soweit vorhanden, den Wert der Eigenschaft Beschriftung <\/b>aus dem Tabellenentwurf auf oder den Namen des Feldes. Fieldindex<\/b> gibt die Reihenfolge an, in welcher die Felder angelegt werden sollen. Die Breite können wir individuell einstellen, genauso wie die Höhe. Bei Feldern mit dem Felddatentyp Langer Text <\/b>kann es sinnvoll sein, höhere Felder zu erstellen. FieldColumn <\/b>ist ein vorbereitender Wert, falls wir noch mehrspaltige Detailformulare unterstützen. ControlType <\/b>wird mit dem Steuerelementtyp entsprechend des Feldes aus der Tabelle gefüllt – normalerweise sind dies Textfelder (109<\/b>), gelegentlich aber auch Kombinationsfelder (111<\/b>) oder Kontrollkästchen (106<\/b>). Die übrigen Eigenschaften sind Nachschlagefeldern vorbehalten und werden ebenfalls aus dem Tabellenentwurf entnommen. Wir können diese aber hier auch nachrüsten.<\/p>\n Ein Klick auf die Schaltfläche Erstellen <\/b>sorgt schließlich dafür, dass ein Formular auf Basis der getätigten Vorgaben erstellt wird (siehe Bild 4). Allein die akkurate Ausrichtung der Steuerelemente würde sonst einige Schritte erfordern, genau wie die manuelle Einstellung der verschiedenen Eigenschaften und des Hinzufügens der Schaltflächen mit dem dahinter liegenden VBA-Code.<\/p>\n Bild 4: Ein automatisch erstelltes Detailformular<\/span><\/b><\/p>\n Die Lösung verwendet aktuell drei Tabellen zum Speichern von Konfigurationsdaten. Die Tabelle tblDetailforms <\/b>speichert die grundlegenden Daten je Formular. Die Tabelle tblDetailfields <\/b>ist über das Fremdschlüsselfeld DetailFormID <\/b>mit dieser Tabelle verbunden. Schließlich gibt es noch die Tabelle tblButtonStyles <\/b>mit den grundlegenden Designeinstellungen für die Schaltflächen. Der jeweilige Style wird über das Feld ButtonStyleID <\/b>der Tabelle tblDetailforms <\/b>selektiert (siehe Bild 5).<\/p>\n Bild 5: Datenmodell des Add-Ins<\/span><\/b><\/p>\n Wir wollen die Lösung dieses Beitrags später als Access-Add-In bereitstellen, damit wir sie in beliebigen Datenbanken nutzen und damit Detailformulare erstellen können. Daher müssen wir an manchen Stellen etwas aufpassen. Zum Beispiel müssen wir unterschieden, ob wir im Code und in den Steuerelementen auf Daten der Add-In-Datenbank zugreifen oder auf die der Host-Datenbank, also der Datenbank, von der aus wir das Access-Ad-In aufgerufen haben.<\/p>\n Das Formular frmDetailforms <\/b>soll beim Laden zunächst die Daten für die Kombinationsfelder bereitstellen.<\/p>\n Die durch das Ereignis Beim Laden <\/b>ausgelöste Prozedur liest zuerst alle Tabellen und Abfragen der Datenbank ein, von der aus das Access-Add-In gestartet wurde (siehe Listing 1). Dies müssen wir mit dem Database<\/b>-Objekt der Host-Datenbank erledigen, die wir mit CurrentDb <\/b>referenzieren. Hier greifen wir auf die Tabelle MSysObjects <\/b>zu, die alle Objekte der Datenbank enthält. Wir filtern hier nach den Werten 1<\/b>, 4<\/b>, 5 <\/b>und 6 <\/b>im Feld Type <\/b>und erhalten so alle Tabellen und Abfragen. Das so ermittelte Recordset weisen wir dem Kombinationsfeld cboDatasource <\/b>zu.<\/p>\n Listing 1: Beim Laden des Formulars ausgelöste Prozedur<\/span><\/b><\/p>\n Die für die Schaltflächen zu verwendenden Icons sollen jedoch aus der Tabelle MSysResources<\/b> der Access-Add-In-Datenbank geholt werden. Diese referenzieren wir nicht mit CurrentDb<\/b>, sondern mit CodeDb<\/b>. Hier holen wir alle Elemente, deren Dateiendung auf png lautet und sortieren diese nach dem Namen. Dieses Recordset weisen wir der entsprechenden Eigenschaft der beiden Kombinationsfelder cboOKButtonIcon <\/b>und cboCancelButtonIcon <\/b>zu.<\/p>\n Wählen wir mit dem Kombinationsfeld cboDatasource <\/b>eine Tabelle oder Abfrage aus, lösen wir die folgende Prozedur aus:<\/p>\n Diese ruft eine weitere Funktion auf, die wir in Listing 2 sehen. Diese nimmt den Namen der Tabelle oder Abfrage als Parameter entgegen und speichert ihn in der Variablen strDataSource<\/b>. Dann öffnen wir ein Recordset auf Basis der Tabelle tblDetailfields<\/b>, der wir die Feldinformationen zuweisen wollen. Das Recordset holt alle Datensätze, die mit dem aktuell im Hauptformular angezeigten Datensatz der Tabelle tblDetailforms <\/b>verknüpft sind. Die Prozedur bewegt den Datensatzzeiger auf den letzten Datensatz, um anschließend die Anzahl der enthaltenen Datensätze zu ermitteln. Ist diese nicht 0<\/b>, stellt die Prozedur dem Benutzer die Frage, ob die Felder neu eingelesen werden sollen. Bejaht der Benutzer dies, löscht die Prozedur zunächst alle für diese Konfiguration bereits vorhandenen Datensätze aus der Tabelle tblDetailfields<\/b>.<\/p>\n Listing 2: Einlesen der Feldinformationen in die Tabelle tblDetailfields<\/span><\/b><\/p>\n Nun referenziert sie mit einem zweiten Recordset die Tabelle, für die wir das Detailformular erstellen wollen, mit der Variablen rstSource<\/b>. Für diese durchlaufen wir alle in der Fields<\/b>-Auflistung enthaltenen Field<\/b>-Elemente und referenzieren das aktuelle Element jeweils mit der Variablen fld<\/b>.<\/p>\n Hier rufen wir nun eine weitere Funktion namens GetControlProperties <\/b>auf und übergeben dieser einen Verweis auf das zu untersuchende Feld. Außerdem übergeben wir einige Variant<\/b>-Variablen, die wir mit den Werten der entsprechenden Eigenschaften des Feldes füllen wollen – diese beschreiben wir gleich im Anschluss.<\/p>\n Nachdem wir die verschiedenen Variant<\/b>-Variablen mit den Eigenschaften des Feldes fld <\/b>gefüllt haben, legen wir einen neuen Datensatz im Recordset der Tabelle tblDetailfields <\/b>an und füllen nacheinander die Eigenschaften. Dazu gehören der Verweis auf den aktuellen Eintrag der Tabelle tblDetailforms<\/b>, der Feldname, der Index, Voreinstellungen von 2.000 und 300 Pixeln für die Steuerelementbreite und -höhe und der Wert 1 <\/b>für die Spalte. Danach folgen die Beschriftung für das Steuerelement, der Steuerelementtyp und dann einige Eigenschaften, die nur für Nachschlagefelder benötigt werden. Danach speichern wir den neuen Datensatz mit der Update<\/b>-Methode und liefern der aufrufenden Prozedur den Wert True <\/b>zurück.<\/p>\n Die aufrufende Prozedur cboDatasource_AfterUpdate<\/b> prüft schließlich noch, ob txtFormname <\/b>und txtFormTitel <\/b>bereits gefüllt sind. Falls nicht, trägt sie für txtFormname <\/b>einen Wert ein, der dem Tabellen- oder Abfragenamen entspricht, aber das Präfix tbl <\/b>oder qry <\/b>durch frm <\/b>ersetzt. Für das Feld txtFormTitle <\/b>trägt die Prozedur ebenfalls den Namen der Datenquelle ein, ersetzt aber die Präfixe tbl <\/b>und qry <\/b>ersatzlos.<\/p>\n Die bereits angesprochene Funktion GetControlProperties <\/b>nimmt einen Verweis auf ein Field<\/b>-Objekt entgegen und ermittelt einige Eigenschaften dieses Feldes (siehe Listing 3).<\/p>\n Listing 3: Ermitteln verschiedener Feldeigenschaften<\/span><\/b><\/p>\n Dabei deaktivieren wir zuerst die eingebaute Fehlerbehandlung und greifen dann auf die beiden Eigenschaften Caption <\/b>und DisplayControl <\/b>zu. Caption <\/b>wird nur gesetzt, wenn wir im Tabellenentwurf die Eigenschaft Beschriftung für ein Feld füllen. DisplayControl <\/b>wird nur angelegt, wenn wir ein Nachschlagefeld anlegen oder ein Ja<\/b>\/Nein<\/b>-Feld. Daher löst der Zugriff auf eine solche Eigenschaft einen Fehler aus, wenn diese nicht vorhanden ist. Wir lesen diese bei deaktivierter Fehlerbehandlung ein und prüfen danach zuerst den Wert von intControlType<\/b>.<\/p>\n Abhängig von diesem Wert lesen wir weitere Informationen ein – beim Wert acComboBox zum Beispiel noch die gebundene Spalte, den Herkunftstyp, die Datensatzherkunft, die Anzahl der Spalten und die Spaltenbreiten.<\/p>\n Danach geben wir die entsprechenden Informationen mit den Variant<\/b>-Parametern an die aufrufende Prozedur ReadFieldsFromTable <\/b>zurück, welche diese in den entsprechenden neuen Datensatz der Tabelle tblDetailfields <\/b>schreibt.<\/p>\n Die Tabelle tblDetailfields <\/b>sieht nach diesem Schritt beispielsweise wie in Bild 6 aus.<\/p>\n Bild 6: Werte der Tabelle tblDetailfields nach dem Einlesen der Felder der Quelltabelle<\/span><\/b><\/p>\n Klicken wir auf die Schaltfläche cmdButtonStyles<\/b>, lösen wir die folgende Prozedur aus:<\/p>\n Diese öffnet das Formular frmButtonStyles<\/b>, das an die Tabelle tblButtonStyles <\/b>gebunden ist und in der Entwurfsansicht wie in Bild 7 aussieht. Dieses Formular ruft beim Anzeigen eines Datensatzes die folgende Prozedur auf:<\/p>\n Bild 7: Entwurfsansicht des Formulars frmButtonStyles<\/span><\/b><\/p>\n Diese startet eine weitere Prozedur namens SetButtonStyle<\/b>. Diese wendet die aktuellen Einstellungen auf das für die Vorschau verwendete Button<\/b>-Element cmdPreview <\/b>an:<\/p>\n Diese Prozedur wird auch durch die übrigen Steuerelemente zum Einstellen der Eigenschaften aufgerufen:<\/p>\n Beim Anklicken der OK<\/b>-Schaltfläche wird das Formular unsichtbar gemacht:<\/p>\n Dadurch läuft der aufrufende Code weiter und prüft, ob das Formular frmButtonStyles <\/b>noch geöffnet ist. Ist das der Fall, liest sie den aktuellen Datensatz aus dem Formular ein und wählt diesen im Kombinationsfeld cboButtonStyleID <\/b>aus.<\/p>\n Nun schauen wir uns an, was geschieht, wenn wir alle notwendigen Einstellungen getroffen haben und die Erstellen<\/b>-Schaltfläche betätigen. Diese hat den folgenden Code und speichert erst einmal die aktuellen Einstellungen:<\/p>\n Danach ruft sie die Funktion CreateNewForm <\/b>auf, der sie den Formularnamen übergibt (siehe Listing 4). Die Funktion beschreiben wir weiter unten. Sie erstellt ein neues Formular und speichert es unter dem angegebenen Namen.<\/p>\n\n
Vorbereitungen im Datenmodell<\/h2>\n
Das Konfigurationsformular im Überblick<\/h2>\n
![\"Formular](\"..\/fileadmin\/_temp_\/2024_02\/pic_1490_002.png\")
<\/p>\n![\"Formular](\"..\/fileadmin\/_temp_\/2024_02\/pic_1490_003.png\")
<\/p>\nDetailformular erstellen<\/h2>\n
![\"Ein](\"..\/fileadmin\/_temp_\/2024_02\/pic_1490_004.png\")
<\/p>\nTabellen der Lösung<\/h2>\n
![\"Datenmodell](\"..\/fileadmin\/_temp_\/2024_02\/pic_1490_005.png\")
<\/p>\nPlanung der Lösung als Access-Add-In<\/h2>\n
Programmierung des Formulars frmDetailforms<\/h2>\n
Private Sub <\/span>Form_Load()\r\n Dim <\/span>db As <\/span>DAO.Database\r\n Dim <\/span>dbc As <\/span>DAO.Database\r\n Dim <\/span>rst As <\/span>DAO.Recordset\r\n Dim <\/span>rstIcons As <\/span>DAO.Recordset\r\n Set<\/span> db = CurrentDb\r\n Set<\/span> dbc = CodeDb\r\n Set<\/span> rst = db.OpenRecordset(\"SELECT Name FROM MSysObjects WHERE Type IN (1, 4, 5, 6) AND Name NOT LIKE ''F_*'' \" _\r\n & \"AND Name NOT LIKE ''MSys*'' AND Name NOT LIKE ''USys*'' AND Name NOT LIKE ''~*''\", dbOpenDynaset)\r\n Set<\/span> Me!cboDatasource.Recordset = rst\r\n Set<\/span> rstIcons = dbc.OpenRecordset(\"SELECT id, [Name] FROM MSysResources WHERE Extension = ''png'' ORDER BY [Name]\", _\r\n dbOpenDynaset)\r\n Set<\/span> Me!cboOKButtonIcon.Recordset = rstIcons\r\n Set<\/span> Me!cboCancelButtonIcon.Recordset = rstIcons\r\nEnd Sub<\/span><\/pre>\nFelder der gewählten Datensatzquelle einlesen<\/h2>\n
Private Sub <\/span>cboDatasource_AfterUpdate()\r\n If <\/span>ReadFieldsFromTable(Me!cboDatasource) = True<\/span> Then<\/span>\r\n Me!sfmDetailforms.Form.Requery\r\n End If<\/span>\r\n If <\/span>Len<\/span>(Nz(Me!txtFormname, \"\")) = 0 Then<\/span>\r\n Me!txtFormname = Replace<\/span>(Replace<\/span>( _\r\n Me!cboDatasource, \"tbl\", \"frm\"), \"qry\", \"frm\")\r\n End If<\/span>\r\n If <\/span>Len<\/span>(Nz(Me!txtFormTitle, \"\")) = 0 Then<\/span>\r\n Me!txtFormTitle = Replace<\/span>(Replace<\/span>(_\r\n Me!cboDatasource, \"tbl\", \"\"), \"qry\", \"\")\r\n End If<\/span>\r\nEnd Sub<\/span><\/pre>\nPublic Function <\/span>ReadFieldsFromTable(strDataSource As String<\/span>) As Boolean<\/span>\r\n Dim <\/span>db As <\/span>DAO.Database, dbc As <\/span>DAO.Database, rst As <\/span>DAO.Recordset, rstSource As <\/span>DAO.Recordset\r\n Dim <\/span>bolReadFields As Boolean<\/span>, intControlType As <\/span>AcControlType\r\n Dim <\/span>varRowSourceType As Variant<\/span>, varRowSource As Variant<\/span>, varBoundColumn As Variant<\/span>\r\n Dim <\/span>varCaption As Variant<\/span>, varColumnCount As Variant<\/span>, varColumnWidths As Variant<\/span>\r\n Dim <\/span>fld As <\/span>DAO.Field, i As Integer<\/span>\r\n strDataSource = Me!cboDatasource\r\n Set<\/span> db = CurrentDb\r\n Set<\/span> dbc = CodeDb\r\n Set<\/span> rst = dbc.OpenRecordset(\"SELECT * FROM tblDetailfields WHERE DetailformID = \" & Me!DetailformID, dbOpenDynaset)\r\n If <\/span>Not<\/span> rst.EOF Then<\/span>\r\n rst.MoveLast\r\n End If<\/span>\r\n bolReadFields = True<\/span>\r\n Me.Dirty = False<\/span>\r\n If <\/span>Not<\/span> rst.RecordCount = 0 Then<\/span>\r\n bolReadFields = MsgBox<\/span>(\"Sollen die Felder neu eingelesen werden?\", vbYesNo + vbExclamation, _\r\n \"Felder neu einlesen?\") = vbYes\r\n End If<\/span>\r\n If <\/span>bolReadFields = True<\/span> Then<\/span>\r\n dbc.Execute \"DELETE FROM tblDetailfields WHERE DetailformID = \" & Me!DetailformID, dbFailOnError\r\n Set<\/span> rstSource = db.OpenRecordset(strDataSource, dbOpenDynaset)\r\n For Each fld In rstSource.Fields\r\n Call<\/span> GetControlProperties(fld, varCaption, intControlType, varBoundColumn, varRowSourceType, _\r\n varRowSource, varColumnCount, varColumnWidths)\r\n rst.AddNew<\/span>\r\n rst!DetailformID = Me!txtDetailformID\r\n rst!FieldName = fld.Name\r\n rst!Fieldindex = i\r\n rst!FieldWidth = 2000\r\n rst!Fieldheight = 300\r\n rst!FieldColumn = 1\r\n rst!Fieldlabel = Nz(varCaption, fld.Name)\r\n rst!ControlType = intControlType\r\n rst!RowSourceType = varRowSourceType\r\n rst!RowSource = varRowSource\r\n rst!BoundColumn = varBoundColumn\r\n rst!ColumnCount = varColumnCount\r\n rst!ColumnWidths = varColumnWidths\r\n rst.Update\r\n i = i + 1\r\n Next<\/span> fld\r\n ReadFieldsFromTable = True<\/span>\r\n Me!sfmDetailforms.Form.Requery\r\n Else<\/span>\r\n ReadFieldsFromTable = False<\/span>\r\n End If<\/span>\r\nEnd Function<\/span><\/pre>\nErmitteln von Feldeigenschaften<\/h2>\n
Public Function <\/span>GetControlProperties(fld As <\/span>DAO.Field, varCaption As Variant<\/span>, intControlType As <\/span>AcControlType, _\r\n varBoundColumn As Variant<\/span>, varRowSourceType As Variant<\/span>, varRowSource As Variant<\/span>, varColumnCount As Variant<\/span>, _\r\n varColumnWidths As Variant<\/span>)\r\n intControlType = 0\r\n varCaption = Null\r\n varBoundColumn = Null\r\n varRowSourceType = Null\r\n varRowSource = Null\r\n varColumnCount = Null\r\n varColumnWidths = Null\r\n On Error Resume Next<\/span>\r\n varCaption = fld.Properties(\"Caption\")\r\n intControlType = fld.Properties(\"DisplayControl\")\r\n Select Case intControlType\r\n Case <\/span>acTextBox\r\n Debug.Print<\/span> fld.Name, \"acTextBox\"\r\n Case <\/span>acComboBox\r\n varBoundColumn = fld.Properties(\"BoundColumn\")\r\n varRowSourceType = fld.Properties(\"RowSourceType\")\r\n varRowSource = fld.Properties(\"RowSource\")\r\n varColumnCount = fld.Properties(\"ColumnCount\")\r\n varColumnWidths = fld.Properties(\"ColumnWidths\")\r\n Case <\/span>acCheckBox\r\n Debug.Print<\/span> fld.Name, \"acCheckBox\"\r\n Case Else<\/span>\r\n Debug.Print<\/span> \"anderer Controltype\", intControlType\r\n End Select<\/span>\r\n On Error GoTo<\/span> 0\r\nEnd Function<\/span><\/pre>\n![\"Werte](\"..\/fileadmin\/_temp_\/2024_02\/6pic_1490_005.png\")
<\/p>\nButton-Style auswählen und einstellen<\/h2>\n
Private Sub <\/span>cmdButtonStyles_Click()\r\n DoCmd.OpenForm \"frmButtonStyles\", _\r\n WindowMode:=acDialog, OpenArgs:=Me!cboButtonStyleID\r\n If <\/span>IstFormularGeoeffnet(\"frmButtonStyles\") Then<\/span>\r\n Me!cboButtonStyleID = _\r\n Forms!frmButtonStyles!ButtonStyleID\r\n DoCmd.Close acForm, \"frmButtonStyles\"\r\n End If<\/span>\r\nEnd Sub<\/span><\/pre>\n![\"Entwurfsansicht](\"..\/fileadmin\/_temp_\/2024_02\/pic_1490_006.png\")
<\/p>\nPrivate Sub <\/span>Form_Current()\r\n Call<\/span> SetButtonStyle\r\nEnd Sub<\/span><\/pre>\nPrivate Sub <\/span>SetButtonStyle()\r\n With<\/span> Me!cmdPreview\r\n If <\/span>Not<\/span> IsNull(Me!cboBorderStyle) Then<\/span>\r\n .BorderStyle = Me!cboBorderStyle\r\n End If<\/span>\r\n If <\/span>Not<\/span> IsNull(Me!cboBackStyle) Then<\/span>\r\n .BackStyle = Me!cboBackStyle\r\n End If<\/span>\r\n If <\/span>Not<\/span> IsNull(Me!cboAlignment) Then<\/span>\r\n .Alignment = Me!cboAlignment\r\n End If<\/span>\r\n End With<\/span>\r\nEnd Sub<\/span><\/pre>\nPrivate Sub <\/span>BorderStyle_AfterUpdate()\r\n Call<\/span> SetButtonStyle\r\nEnd Sub<\/span>\r\nPrivate Sub <\/span>cboAlignment_AfterUpdate()\r\n Call<\/span> SetButtonStyle\r\nEnd Sub<\/span>\r\nPrivate Sub <\/span>cboBackStyle_AfterUpdate()\r\n Call<\/span> SetButtonStyle\r\nEnd Sub<\/span>\r\nPrivate Sub <\/span>cboBorderStyle_AfterUpdate()\r\n Call<\/span> SetButtonStyle\r\nEnd Sub<\/span><\/pre>\nPrivate Sub <\/span>cmdOK_Click()\r\n Me.Visible = False<\/span>\r\nEnd Sub<\/span><\/pre>\nStart der Erstellung des Detailformulars<\/h2>\n
Private Sub <\/span>cmdCreate_Click()\r\n Dim <\/span>frm As <\/span>Form\r\n Dim <\/span>lngWidth As Long<\/span>\r\n Dim <\/span>lngHeight As Long<\/span>\r\n RunCommand acCmdSaveRecord\r\n If <\/span>CreateNewForm(Me!Formname) = True<\/span> Then<\/span>\r\n DoCmd.OpenForm Me!Formname, acDesign\r\n Set<\/span> frm = Forms(Me!Formname)\r\n With<\/span> frm\r\n .AutoCenter = Me!chkAutocenter\r\n .Caption = Me!txtFormTitle\r\n .DefaultView = acDefViewSingle\r\n .RecordSelectors = Me!chkRecordSelectors\r\n .NavigationButtons = Me!chkNavigationButtons\r\n .DividingLines = False<\/span>\r\n .ScrollBars = Me!cboScrollBars\r\n .RecordSource = Me!cboDatasource\r\n .Cycle = Me!cboCycle\r\n .HasModule = True<\/span>\r\n AddControls Me!DetailformID, lngHeight, lngWidth\r\n .Section(0).Height = lngHeight\r\n .Width = lngWidth\r\n End With<\/span>\r\n End If<\/span>\r\nEnd Sub<\/span><\/pre>\nPublic 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