<\/p>\n
Standardwerte für Felder legt in der Regel der Entwickler beim Definieren des Datenmodells in der Entwurfsansicht der Tabellen fest. Während man in bestimmten Maßen dynamische Werte nutzen kann wie beispielsweise mit der Datum()-Funktion für Datumsfelder, ist man ansonsten recht unflexibel. Leider können nur einige eingebaute Funktionen genutzt werden, benutzerdefinierte VBA-Funktionen sind nicht möglich. Aber welche benutzerdefinierten Standardwerte wollen wir überhaupt nutzen – und wo wollen wir diese festlegen? Die Einsatzzwecke sind vielfältig und prinzipiell können wir jedes Feld mit einem benutzerdefinierten Standardwert nutzen. Wichtig ist der Gedanke dahinter: Sinnvoll gewählte Standardwerte sparen dem Benutzer wertvolle Zeit bei der Dateneingabe. Wenn wir zum Beispiel eine Datenbank planen, die überwiegend weibliche Kontakte verwaltet, ist es sinnvoll, als Anrede „Frau“ vorzugeben. Oder wir haben eine Autowerkstatt, die hauptsächlich Fahrzeuge einer bestimmten Marke repariert – dann macht es Sinn, diese vorzubelegen. Wir können auch dynamisch den zuletzt verwendeten Eintrag als Standardwert angeben oder auch den meistgenutzen. Wie wir dies realisieren, zeigen wir im vorliegenden Beitrag.<\/b><\/p>\nHerkömmliche Standardwerte<\/h2>\n
Das Festlegen von Standardwerten ist recht einfach – man wechselt in den Entwurf der betroffenen Tabelle, klickt das Feld an, dem man einen Standardwert zuweisen will und stellt die Eigenschaft Standardwert <\/b>auf den gewünschten Wert ein.<\/p>\n
Bei Zahlenfeldern legt man so vielleicht den Wert 0 <\/b>fest, bei Datumsfeldern mit dem Ausdruck =Datum() <\/b>das aktuelle Datum oder bei Ja\/Nein<\/b>-Feldern den Wert Ja<\/b>. Das ist schnell gemacht, aber relativ unflexibel – es gibt ein paar eingebaute Funktionen, die man hier nutzen kann, aber ansonsten ist man auf statische Werte angewiesen.<\/p>\nDynamische Standardwerte<\/h2>\n
Wollen wir dies flexibel erledigen, haben wir im Tabellen- und Abfrageentwurf keine Möglichkeiten. Die nächste Ebene sind die Formulare: Hier können wir für Steuerelemente, die an Tabellenfelder gebunden sind, per VBA einen Standardwert definieren. Aber welche Werte wollen wir überhaupt als Standardwerte nutzen? Es gibt zum Beispiel die folgenden Möglichkeiten:<\/p>\n
Die ersten beiden Vorschläge erfordern keine aktive Mitarbeit des Benutzers, der letzte hingegen schon.<\/p>\n
Wenn wir wie in Bild 1 den Namen Andreas <\/b>in das Textfeld txtVorname <\/b>eingeben und wollen, dass dieser fortan als Standardwert verwendet wird, benötigen wir eine VBA-Prozedur, die entweder nach dem Aktualisieren des Steuerelements oder des Formulars ausgelöst wird und die Eigenschaft DefaultValue <\/b>des Textfeldes auf den soeben eingegebenen Wert einstellt.<\/p>\n
![\"Dieser](\"..\/fileadmin\/_temp_\/2023_06\/pic_1466_001.png\")
<\/p>\n
Bild 1: Dieser Wert wurde soeben als Standardwert übernommen<\/span><\/b><\/p>\n In diesem Fall wollen wir dies direkt nach dem Eingeben des Wertes und dem Aktualisieren des Steuerelements erledigen. Dazu hinterlegen wir die folgende Ereignisprozedur:<\/p>\n Wir weisen hier allerdings nicht einfach den Wert des Textfeldes zu, sondern müssen diesen noch in Anführungszeichen einfassen, die wir wie hier durch die entsprechende Chr<\/b>-Funktion angeben oder alternativ beispielsweise mit vier Anführungszeichen:<\/p>\n Auch wenn wir eine feste Zeichenkette angeben wollen, müssen wir diese übrigens in zusätzliche Anführungszeichen einfassen:<\/p>\n Bei Datumsangaben müssen wir das Datum zuvor in einen Zahlenwert konvertieren. Bei reinen Datumsangaben ohne Uhrzeit reicht dies aus:<\/p>\n Wenn wir ein Feld verwenden, das auch eine Uhrzeit enthält, benötigen wir die Funktion CDbl <\/b>– die Nachkommastellen nehmen in diesem Fall die Uhrzeit auf:<\/p>\n Bei Ja\/Nein<\/b>-Feldern greifen wir direkt auf den jeweiligen Wert zu:<\/p>\n Bei Zahlenwerten und Währungsfeldern müssen wir das Komma durch den Punkt ersetzen:<\/p>\n Der Nachteil dieser Methode ist, dass der zuletzt verwendete Wert erst als Standardwert genutzt wird, wenn wir den Inhalt des Steuerelements nach dem Öffnen des Formulars erstmals bearbeitet haben.<\/p>\n Wir müssten uns also eine Möglichkeit überlegen, diesen Wert alternativ zu speichern und ihn wiederherzustellen. Dazu kommen wir weiter unten – erst schauen wir uns die anderen Varianten an.<\/p>\n Wenn wir schon eine VBA-Prozedur verwenden, können wir auch gleich noch andere Methoden zur Ermittlung des Standardwertes nutzen. So können wir beispielsweise ermitteln, welcher Wert in einem Feld am meisten verwendet wurde und diesen als Standardwert in das Feld eintragen.<\/p>\n Dazu verwenden wir die Prozedur aus Listing 1. Diese ermittelt in einem Recordset den Wert des Feldes Nachname<\/b>, der den höchsten Wert für die Anzahl der Werte der Gruppierungen über das Feld Nachname <\/b>enthält. Sprich: Die Abfrage gruppiert die Datensätze nach dem Wert im Feld Nachname<\/b>, zählt diese und verwendet die Anzahl gleich noch als Sortierkriterium.<\/p>\n Listing 1: Einstellen des häufigsten Nachnamens als Standardwert<\/span><\/b><\/p>\n Davon holt sie mit TOP 1 <\/b>den ersten Eintrag. Danach prüft sie, ob die Abfrage einen Datensatz gefunden hat und stellt den Wert der Variablen strNachname <\/b>auf den gefundenen Nachnamen ein. Dieser wird dann als Standardwert des Feldes txtNachname <\/b>festgelegt.<\/p>\n Damit wir sowohl beim Öffnen des Formulars als auch nach dem Aktualisieren eines der Nachnamen jeweils den korrekten Standardwert für dieses Feld angeben können, rufen wir diese Prozedur gleich zwei Mal auf – zuerst in der Prozedur, die durch das Ereignis Beim Öffnen <\/b>des Formulars ausgelöst wird: <\/p>\n Zweitens nach dem Ändern des Wertes für einen Datensatz im Feld Nachname<\/b>:<\/p>\n Den Standardwert können wir also auch gleich beim Öffnen des Formulars zu setzen – und zwar in den Prozeduren für die Ereigniseigenschaften Beim Laden<\/b> und Beim Öffnen<\/b>.<\/p>\n Nun fehlt noch eine Möglichkeit, diese Standardwerte zu speichern, denn wie wir oben beschrieben haben, sind diese nach dem erneuten Öffnen des Formulars wieder geleert. Wir haben zwar gesehen, dass wir in den Ereignisprozeduren Form_Load <\/b>oder Form_Open <\/b>die Werte neu einstellen können. Hier können wir aber beispielsweise nicht den zuletzt verwendeten Wert einstellen, da dieser nicht gespeichert wird. Dies würde höchstes gelingen, wenn wir die Anforderung so definieren, dass der Wert des zuletzt angelegten Datensatzes als Standardwert verwendet wird. Dann würden wir beispielsweise diese Prozedur nutzen, die durch das Ereignis Beim Anzeigen <\/b>ausgelöst wird – also beim Wechseln zu einem anderen Datensatz und somit auch zu einem neuen, leeren Datensatz:<\/p>\n Hier ermitteln wir mit DMax <\/b>die höchste Zahl im Feld ID<\/b>, was in der Regel dem zuletzt angelegten Datensatz entspricht. Diese verwenden wir als Parameter für einen Aufruf der DLookup<\/b>-Funktion, um die passende Anrede dazu zu finden. Das Ergebnis schreiben wir anschließend als Standardwert in das Textfeld txtAnrede<\/b>.<\/p>\n Damit kommen wir endgültig zum Speichern der Standardwerte. Wenn dies gewünscht ist, benötigen wir einen Ort, wo wir die Werte speichern können.<\/p>\n Da wir ohnehin in einer Access-Datenbank arbeiten, legen wir dazu logischerweise eine eigene Tabelle an, die wir beispielsweise tblStandardwerte <\/b>nennen. Hier wollen wir zunächst die folgenden Informationen speichern:<\/p>\n Danach folgt der eigentlich interessante Wert, nämlich der Standardwert. Hier stellt sich die Frage, ob wir für jeden Datentyp ein eigenes Feld anlegen oder einfach alle Werte in ein Feld mit dem Datentyp speichern, der alles speichern kann – nämlich in einem Textfeld.<\/p>\n Darüber hinaus ließen sich je nach Einsatzzweck noch weitere Felder einfügen:<\/p>\n Bevor wir an die Umsetzung gehen, schauen wir uns die Möglichkeiten für Mehrbenutzer an. Hier gibt es zwei Varianten:<\/p>\n Wir gehen der Einfachheit halber davon aus, dass wir entweder eine Einzelbenutzer-Anwendung haben oder dass jeder Benutzer eine Kopie des Frontends mit der Tabelle tblStandardwerte <\/b>in seinem Benutzerverzeichnis hat.<\/p>\n Die Benutzeroberfläche gestalten wir je nach den möglichen Elementen des Datenmodells, die wir oben vorgestellt haben. Um den Rahmen nicht zu sprengen, wollen wir die folgenden Daten darstellen:<\/p>\n Die Tabelle tblStandardwerte<\/b> sieht in der Entwurfsansicht schließlich wie in Bild 2 aus. Für die Kombination der beiden Felder Tabellenname <\/b>und Feldname <\/b>haben wir einen eindeutigen Schlüssel definiert, damit kein Feldname doppelt zu einer Tabelle zugeordnet werden kann.<\/p>\n Bild 2: Festlegen eines eindeutigen, zusammengesetzten Indexes<\/span><\/b><\/p>\n Für das Feld DatentypID <\/b>haben wir ein Nachschlagefeld eingerichtet, das mit der Tabelle tblDatentypen <\/b>verknüpft ist. Auf diese Weise brauchen wir dort nur die dem Datentyp entsprechende Zahl zu speichern. Die damit verknüpfte Tabelle heißt tblDatentypen <\/b>und enthält im Feld ID <\/b>den Zahlenwert, den wir anschließend per VBA für das jeweilige Feld ermitteln, im Feld Datentyp <\/b>die VBA-Konstante für den Datentyp sowie eine Beschreibung <\/b>(siehe Bild 3).<\/p>\n Bild 3: Datentypen für die Standardwerte<\/span><\/b><\/p>\n Um die Standardwerte zu verwalten, erstellen wir zwei Formulare. Das Unterformular sfmStandardwerte<\/b> soll die Daten der Tabelle tblStandardwerte <\/b>in der Datenblattansicht anzeigen. Dazu weisen wir dem Formular diese Tabelle für die Eigenschaft Datensatzquelle <\/b>zu und ziehen die drei Felder Tabellenname<\/b>, Feldname <\/b>und Standardwert <\/b>in den Detailbereich des Entwurfs.<\/p>\n Anschließend speichern und schließen wir das Unterformular und ziehen es aus dem Navigationsbereich in den Entwurf des Hauptformulars frmStandardwerte<\/b>. Hier fügen wir noch eine Schaltfläche hinzu, mit der wir die Felder der Tabellen der aktuellen Datenbank in die Tabelle tblStandardwerte <\/b>einlesen können.<\/p>\n Außerdem wollen wir mit dem Kontrollkästchen chkStandardwerteUebernehmen<\/b> festlegen, ob die Standardwerte aus den Felddefinitionen übernommen werden sollen, was nur beim ersten Einlesen empfehlenswert ist (siehe Bild 4).<\/p>\n Bild 4: Entwurf von Haupt- und Unterformular<\/span><\/b><\/p>\n Die Schaltfläche cmdFelderEinlesen <\/b>löst die folgende Prozedur aus. Diese ruft zwei weitere Routinen auf, von denen die erste die im Datenmodell vorhandenen Felder einliest und die zweite prüft, ob alle in der Tabelle tblStandardwerte <\/b>angegebenen Felder noch vorhanden sind. Danach aktualisiert sie das Unterformular sfmStandardwerte <\/b>mit der Requery<\/b>-Methode:<\/p>\n Die Prozedur FelderEinlesen <\/b>nimmt den Wert des Kontrollkästchens chkStandardwerteUebernehmen <\/b>als optionalen Parameter entgegen, der standardmäßig auf False<\/b> eingestellt ist (siehe Listing 2).<\/p>\n [<\/p>\n Listing 2: Speichern der Felder in der Tabelle tblStandardwerte<\/span><\/b><\/p>\n Sie durchläuft in einer For Each<\/b>-Schleife alle Tabellendefinitionen der aktuellen Datenbank und prüft in einer Select Case<\/b>-Bedingung, ob der Tabellenname bestimmten Namen wie MSys*<\/b>, USys*<\/b>, tblStandardwerte <\/b>oder tblDatentypen <\/b>entspricht. Diese Tabellen sollen beim Einlesen nicht berücksichtigt werden.<\/p>\n Für alle anderen durchläuft die Prozedur die Fields<\/b>-Auflistung mit allen Feldern. Nach der Deaktivierung der eingebauten Fehlerbehandlung prüft die Prozedur, ob die Standardwerte übernommen werden sollen. Falls ja, versucht sie, für die aktuelle Kombination aus Tabellenname und Feldname einen neuen Datensatz inklusive Standardwert und Felddatentyp in der Tabelle tblStandardwerte <\/b>anzulegen. Das könnte einen Fehler auslösen, wenn diese Kombination bereits vorhanden ist. In diesem Fall wird in der folgenden Select Case<\/b>-Bedingung geprüft, ob die Fehlernummer 3022 <\/b>lautet. Dieser Fehler wird immer ausgelöst, wenn man versucht, einen Datensatz anzulegen, dessen Kombination aus Schlüsselwerten bereits in einem anderen Datensatz vorliegt. In diesem Fall wollen wir die Werte für diesen Datensatz überschreiben, was wir mit einer UPDATE-SQL-Anweisung erledigen, die genau die Daten für den Datensatz mit dem Tabellennamen und dem Feldnamen aktualisiert. Die Aktualisierung bezieht sich auf den Felddatentyp und gegebenenfalls auf den im Tabellenentwurf gespeicherten Standardwert. Auch haben wir zwei Varianten – eine mit Übernahme der Standardwerte aus dem Tabellenentwurf und eine ohne.<\/p>\n Wenn wir diese Prozedur ausführen, erhalten wir bereits die gewünschten Daten im Formular (siehe Bild 5).<\/p>\n Bild 5: Liste der Standardwerte<\/span><\/b><\/p>\n Mit der Prozedur FelderEinlesen <\/b>haben wir auch bereits die Änderungen von Felddatentypen berücksichtigt – diese werden durch die UPDATE<\/b>-Anweisungen in die Tabelle tblStandardwerte <\/b>übernommen.<\/p>\n Gelegentlich löscht man Felder aus dem Tabellenentwurf. Dem wollen wir gerecht werden, indem wir mit der Prozedur FelderEntfernen<\/b> alle in der Tabelle tblStandardwerte <\/b>gespeicherten Kombinationen aus Tabellen und Feldern prüfen.<\/p>\n Die Prozedur durchläuft alle Datensätze des Recordsets auf Basis der Tabelle tblStandardwerte<\/b>. Dabei stellt sie den Wert der Field<\/b>-Variablen fld <\/b>zuerst auf Nothing <\/b>ein. Danach versucht sie, bei deaktivierter Fehlerbehandlung auf das Feld zuzugreifen, das sich in der Tabellendefinition aus rst!Tabellenname <\/b>befindet und dem Feld mit dem Namen aus rst!Feldname <\/b>entspricht. Ist fld <\/b>danach leer, ist das Feld offensichtlich nicht mehr vorhanden. In diesem Fall löscht die Prozedur den aktuellen Datensatz mit der Delete<\/b>-Methode des Recordset<\/b>-Objekts aus der Tabelle tblStandardwerte<\/b>. Dieser Vorgang wird für alle in der Tabelle tblStandardwerte<\/b> enthaltenen Datensätze wiederholt, sodass dort anschließend keine Standardwerte mehr für Felder vorliegen, die nicht in den Tabellen der Datenbank enthalten sind:<\/p>\n Nun wollen wir dem Benutzer erlauben, neue Standardwerte für die Felder der Tabellen festzulegen. Eigentlich können wir ihm dazu einfach erlauben, die Werte in das Feld Standardwert <\/b>im Unterformular einzugeben. Wir müssen allerdings dafür Sorge tragen, dass er einen Wert eingibt, der dem Datentyp entspricht, der für dieses Feld festgelegt ist. Also müssen wir eine Validierung hinterlegen, die prüft, ob der Wert gültig ist.<\/p>\n Als Erstes wollen wir jedoch sicherstellen, dass der Benutzer nicht den Tabellen- und den Feldnamen ändern kann. Dazu stellen wir die Eigenschaft Aktiviert <\/b>auf Nein <\/b>und Gesperrt <\/b>auf Ja <\/b>ein. Dadurch erreichen wir, dass die Steuerelemente zwar nicht mehr editierbar sind, aber dennoch nicht ausgegraut werden, wie es der Fall wäre, wenn man nur die eigenschaft Aktiviert <\/b>auf Nein <\/b>einstellt (siehe Bild 6).<\/p>\n Bild 6: Deaktivieren der beiden Textfelder txtTabellenname und txtFeldname<\/span><\/b><\/p>\n Die Namen der Steuerelemente haben wir übrigens zuvor auf txtTabellenname<\/b>, txtFeldname <\/b>und txtStandardwert <\/b>eingestellt.<\/p>\n Wir wollen uns an dieser Stelle auf die Änderung folgender Felddatentypen beschränken:<\/p>\n Für die ersten drei Kategorien wollen wir jeweils ein kleines Popup-Formular zum Ändern der Inhalte anzeigen, da wir hier eine Validierung einbauen müssen, die sicherstellt, dass der Benutzer Werte des entsprechenden Datentyps eingibt. Für die Felder mit Texten benötigen wir dies nicht.<\/p>\n Diese Formulare sollen beim Anklicken des Feldes txtStandardwert <\/b>automatisch angezeigt werden, den aktuellen Inhalt anzeigen und die Möglichkeit bieten, einen neuen Wert einzugeben. Dabei sollen die Formulare eine OK<\/b>– und eine Abbrechen<\/b>-Schaltfläche enthalten. Die OK<\/b>-Schaltfläche soll den Inhalt übernehmen, die Abbrechen<\/b>-Schaltfläche soll die Eingabe verwerfen.<\/p>\n Die Popup-Formulare sollen genau an der Position des Mauszeigers erscheinen, wenn der Benutzer in das Textfeld txtStandardwert <\/b>des Unterformulars klickt.<\/p>\n Die dazu notwendige Technik haben wir im Beitrag Formular an Mausposition öffnen <\/b>(www.access-im-unternehmen.de\/1465<\/b>) vorgestellt.<\/p>\n Damit beim Anklicken des Textfeldes txtStandardwert <\/b>das jeweilige Popup-Formular angezeigt wird, fügen wir dem Textfeld Ereignisprozeduren für die Ereigniseigenschaften Bei Maustaste ab <\/b>und Bei Maustaste auf <\/b>hinzu. Diese finden wir in Listing 3. In txtStandardwert_MouseDown <\/b>merken wir uns die Position des Mauszeigers in der Variablen pt<\/b>. In der Prozedur txtStandardwert_MouseUp <\/b>zeigen wir schließlich die Popup-Formulare an. Dazu prüfen wir zuerst, ob der Benutzer mit der linken Maustaste auf einen der Standardwerte geklickt hat. Ist das der Fall, schreiben wir die Koordinaten des Mauszeigers in die öffentlichen Variablen lngX <\/b>und lngY<\/b>.<\/p>\nPrivate Sub <\/span>txtVorname_AfterUpdate()\r\n Me!txtVorname.DefaultValue = _\r\n Chr(34) & Me!txtVorname & Chr(34)\r\nEnd Sub<\/span><\/pre>\nMe!txtVorname.DefaultValue = \"\"\"\" & Me!txtVorname & \"\"\"\"<\/pre>\n
Me!txtVorname.DefaultValue = \"\"\"Beispiel\"\"\"<\/pre>\n
Standardwert für weitere Datentypen<\/h2>\n
Private Sub <\/span>txtGeburtsdatum_AfterUpdate()\r\n Me!txtGeburtsdatum.DefaultValue = CLng(Me!txtGeburtsdatum)\r\nEnd Sub<\/span><\/pre>\nMe!txtGeburtsdatum.DefaultValue = CDbl(Me!txtGeburtsdatum)<\/pre>\n
Private Sub <\/span>chkAktiv_AfterUpdate()\r\n Me!chkAktiv.DefaultValue = Me!chkAktiv\r\nEnd Sub<\/span><\/pre>\nPrivate <\/span> Sub txtTaschengeld_AfterUpdate()\r\n Me!txtTaschengeld.DefaultValue = _\r\n Replace<\/span>(Me!txtTaschengeld, \",\", \".\")\r\nEnd Sub<\/span> \r\nPrivate Sub <\/span>txtGewicht_AfterUpdate()\r\n Me!txtGewicht.DefaultValue = _\r\n Replace<\/span>(Me!txtGewicht, \",\", \".\")\r\nEnd Sub<\/span><\/pre>\nNachteil: Kein Speichern des Standardwerts<\/h2>\n
Am meisten verwendeten Wert als Standardwert nutzen<\/h2>\n
Private Sub <\/span>NachnameStandardwert()\r\n Dim <\/span>db As <\/span>DAO.Database\r\n Dim <\/span>rst As <\/span>DAO.Recordset\r\n Dim <\/span>strNachname As String<\/span>\r\n Set<\/span> db = CurrentDb\r\n Set<\/span> rst = db.OpenRecordset(\"SELECT TOP 1 Nachname FROM tblPersonen GROUP BY Nachname ORDER BY COUNT(*) DESC\")\r\n If <\/span>Not<\/span> rst.EOF Then<\/span>\r\n strNachname = rst.Fields(0)\r\n End If<\/span>\r\n Me!txtNachname.DefaultValue = \"\"\"\" & strNachname & \"\"\"\"\r\nEnd Sub<\/span><\/pre>\nPrivate Sub <\/span>Form_Open(Cancel As Integer<\/span>)\r\n Call<\/span> NachnameStandardwert\r\nEnd Sub<\/span><\/pre>\nPrivate Sub <\/span>txtNachname_AfterUpdate()\r\n Call<\/span> NachnameStandardwert\r\nEnd Sub<\/span><\/pre>\nStandardwert beim Öffnen einstellen<\/h2>\n
Wert aus dem zuletzt hinzugefügten Datensatz ermitteln<\/h2>\n
Private Sub <\/span>Form_Current()\r\n Dim <\/span>strAnrede As String<\/span>\r\n strAnrede = Nz(DLookup(\"Anrede\", \"tblPersonen\", _\r\n \"ID = \" & Nz(DMax(\"ID\", \"tblPersonen\"), 0)), \"\")\r\n Me!txtAnrede.DefaultValue = \"\"\"\" & strAnrede & \"\"\"\"\r\nEnd Sub<\/span><\/pre>\nStandardwerte speichern<\/h2>\n
\n
\n
Mehrbenutzer<\/h2>\n
\n
Tabellen zum Verwalten der Standardwerte<\/h2>\n
\n
![\"Festlegen](\"..\/fileadmin\/_temp_\/2023_06\/pic_1466_004.png\")
<\/p>\n![\"Datentypen](\"..\/fileadmin\/_temp_\/2023_06\/pic_1466_005.png\")
<\/p>\nEntwurf der Benutzeroberfläche<\/h2>\n
![\"Entwurf](\"..\/fileadmin\/_temp_\/2023_06\/pic_1466_006.png\")
<\/p>\nFelder und Standardwerte einlesen<\/h2>\n
Private Sub <\/span>cmdFelderEinlesen_Click()\r\n Call<\/span> FelderEinlesen(Me!chkStandardwerteUebernehmen)\r\n Call<\/span> FelderEntfernen\r\n Me!sfmStandardwerte.Requery\r\nEnd Sub<\/span><\/pre>\nPublic Sub <\/span>FelderEinlesen(Optional<\/span> bolStandardwerteUebernehmen As Boolean<\/span> = False<\/span>)\r\n Dim <\/span>db As <\/span>DAO.Database\r\n Dim <\/span>tdf As <\/span>DAO.TableDef\r\n Dim <\/span>fld As <\/span>DAO.Field\r\n Set<\/span> db = CurrentDb\r\n For Each tdf In db.TableDefs\r\n Select Case True<\/span>\r\n Case <\/span>tdf.Name Like \"MSys*\"\r\n Case <\/span>tdf.Name Like \"USys*\"\r\n Case <\/span>tdf.Name = \"tblStandardwerte\"\r\n Case <\/span>tdf.Name = \"tblDatentypen\"\r\n Case Else<\/span>\r\n For Each fld In tdf.Fields\r\n On Error Resume Next<\/span>\r\n If <\/span>bolStandardwerteUebernehmen Then<\/span>\r\n db.Execute \"INSERT INTO tblStandardwerte(Tabellenname, Feldname, Standardwert, DatentypID) \" _\r\n & \"VALUES(''\" & tdf.Name & \"'', ''\" & fld.Name & \"'', ''\" & fld.DefaultValue & \"'', \" _\r\n & fld.Type & \")\", dbFailOnError\r\n Else<\/span>\r\n db.Execute \"INSERT INTO tblStandardwerte(Tabellenname, Feldname, DatentypID) VALUES(''\" _\r\n & tdf.Name & \"'', ''\" & fld.Name & \"'', \" & fld.Type & \")\", dbFailOnError\r\n End If<\/span>\r\n Select Case Err.Number\r\n Case <\/span>3022\r\n If <\/span>bolStandardwerteUebernehmen Then<\/span>\r\n db.Execute \"UPDATE tblStandardwerte(Tabellenname, Feldname, Standardwert, \" _\r\n & \"DatentypID) VALUES(''\" & tdf.Name & \"'', ''\" & fld.Name & \"'', ''\" _\r\n & fld.DefaultValue & \"'', \" & fld.Type & \") WHERE Tabellenname = ''\" & tdf.Name _\r\n & \"'' AND Feldname = ''\" & fld.Name & \"''\", dbFailOnError\r\n Else<\/span>\r\n db.Execute \"UPDATE tblStandardwerte(Tabellenname, Feldname, DatentypID) VALUES(''\" _\r\n & tdf.Name & \"'', ''\" & fld.Name & \"'', \" & fld.Type & \") WHERE Tabellenname = ''\" _\r\n & tdf.Name & \"'' AND Feldname = ''\" & fld.Name & \"''\", dbFailOnError\r\n End If<\/span>\r\n Case <\/span>0\r\n Case Else<\/span>\r\n MsgBox<\/span> \"Fehler \" & Err.Number & \":\" & vbCrLf<\/span> & vbCrLf<\/span> & Err.Description\r\n End Select<\/span>\r\n Next<\/span> fld\r\n End Select<\/span>\r\n Next<\/span> tdf\r\nEnd Sub<\/span><\/pre>\n![\"Liste](\"..\/fileadmin\/_temp_\/2023_06\/pic_1466_007.png\")
<\/p>\nGelöschte Felder aus den Standardwerten entfernen<\/h2>\n
Public Sub <\/span>FelderEntfernen()\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 Set<\/span> db = CurrentDb\r\n Set<\/span> rst = db.OpenRecordset( _\r\n & \"SELECT * FROM tblStandardwerte\", dbOpenDynaset)\r\n Do While<\/span> Not<\/span> rst.EOF\r\n Set<\/span> fld = Nothing\r\n On Error Resume Next<\/span>\r\n Set<\/span> fld = db.TableDefs(rst!Tabellenname). _\r\n Fields(rst!Feldname)\r\n On Error GoTo<\/span> 0\r\n If <\/span>fld Is Nothing Then<\/span>\r\n rst.Delete\r\n End If<\/span>\r\n rst.MoveNext<\/span>\r\n Loop<\/span>\r\nEnd Sub<\/span><\/pre>\nStandardwerte einstellen<\/h2>\n
![\"Deaktivieren](\"..\/fileadmin\/_temp_\/2023_06\/pic_1466_008.png\")
<\/p>\nFelddatentypen für Standardwerte<\/h2>\n
\n
Popup-Formulare zum Ändern der Standardwerte<\/h2>\n
Aufrufen der Popup-Formulare<\/h2>\n
Private <\/span>pt As <\/span>POINTAPI\r\nPrivate Sub <\/span>txtStandardwert_MouseDown(Button As Integer<\/span>, Shift As Integer<\/span>, X As Single<\/span>, Y As Single<\/span>)\r\n If <\/span>Button = acLeftButton Then<\/span>\r\n GetCursorPos pt\r\n End If<\/span>\r\nEnd Sub<\/span>\r\nPrivate Sub <\/span>txtStandardwert_MouseUp(Button As Integer<\/span>, Shift As Integer<\/span>, X As Single<\/span>, Y As Single<\/span>)\r\n Dim <\/span>strFormular As String<\/span>\r\n If <\/span>Button = acLeftButton Then<\/span>\r\n lngX = pt.X\r\n lngY = pt.Y\r\n Select Case Me!DatentypID\r\n Case <\/span>dbBoolean\r\n strFormular = \"frmStandardwertBoolean\"\r\n DoCmd.OpenForm strFormular, OpenArgs:=Me!txtStandardwert, WindowMode:=acDialog\r\n If <\/span>IstFormularGeoeffnet(strFormular) Then<\/span>\r\n Me!txtStandardwert = Forms(strFormular)!chk\r\n DoCmd.Close acForm, strFormular\r\n End If<\/span>\r\n Case <\/span>dbByte, dbInteger, dbLong, dbCurrency, dbSingle, dbDouble, dbBigInt, dbDecimal\r\n strFormular = \"frmStandardwertNumeric\"\r\n DoCmd.OpenForm strFormular, OpenArgs:=Me!txtStandardwert, WindowMode:=acDialog\r\n If <\/span>IstFormularGeoeffnet(strFormular) Then<\/span>\r\n Me!txtStandardwert = Forms(strFormular)!txt\r\n DoCmd.Close acForm, strFormular\r\n End If<\/span>\r\n Case <\/span>dbDate\r\n strFormular = \"frmStandardwertDate\"\r\n DoCmd.OpenForm strFormular, OpenArgs:=Me!txtStandardwert, WindowMode:=acDialog\r\n If <\/span>IstFormularGeoeffnet(strFormular)