<\/p>\n
In vielen Fällen können Sie dem Benutzer bei der Nutzung Ihrer Anwendung durch die Vorgabe von Standardwerten Arbeit abnehmen. Oft kristallisiert sich aber erst später heraus, welche die gewünschten Standardwerte sind oder diese unterscheiden sich je nach Benutzer. Dann wäre es praktisch, wenn die Benutzer selbst die Standardwerte für das Anlegen neuer Datensätze vorgeben könnten. Vielleicht möchten Sie sogar, dass der nächste neue Datensatz die Werte des vorherigen Datensatzes als Standardwerte übernimmt Wie dies gelingt, zeigt der vorliegende Beitrag.<\/b><\/p>\n
Als Beispielformular nutzen wir ein einfaches Detailformular namens frmArtikel<\/b>, welches die Daten der Tabelle tblArtikel <\/b>der Beispieldatenbank anzeigt.<\/p>\n
Angenommen, die Datenbank enthält überwiegend Artikel einer bestimmten Kategorie, beispielsweise der Kategorie Getränke <\/b>mit dem Primärschlüsselwert 1<\/b>, dann könnte es dem Benutzer einige Arbeit sparen, wenn dieser Wert beim Anlegen eines neuen Datensatzes bereits voreingestellt wird. Dies erledigen Sie über die Eigenschaft Standardwert <\/b>des Kombinationsfeldes zur Anzeige der Kategorie im Entwurf des Formulars (s. Bild 1).<\/p>\n
![\"Formular](\"..\/fileadmin\/_temp_\/2016_05\/pic_1052_001.png\")
<\/p>\n
Bild 1: Formular mit der Standardwert-Eigenschaft im Entwurf<\/span><\/b><\/p>\n Wenn Sie dann in die Formularansicht wechseln und einen neuen Datensatz anzeigen, erscheint im Kombinationsfeld Kategorie<\/b> bereits der voreingestellte Eintrag (s. Bild 2). Dies ändert sich allerdings auch nicht beim Anlegen weiterer Datensätze.<\/p>\n Bild 2: Kategorie Getränke als Standardwert<\/span><\/b><\/p>\n Da wir die Felder direkt aus der Feldliste in das Formular gezogen haben, hat Access die Namen der Felder als Steuerelementnamen übernommen. Das kann in manchen Situationen zu Problemen führen, wenn Sie per VBA auf das Steuerelement zugreifen wollen – etwa, um die Eigenschaft DefaultValue <\/b>einzustellen. Diese ist nämlich nur für Steuerelemente verfügbar, nicht aber für die Felder der Datenherkunft des Formulars, die aber – wenn Steuerelement und Feld den gleichen Namen tragen – auf die gleiche Weise referenziert werden. Um Missverständnissen vorzubeugen, sollten Sie also das Steuerelement mit einem Präfix versehen, also etwa txt <\/b>für Textfelder oder cbo <\/b>für Kombinationsfelder. Sie können ganz einfach testen, dass DefaultValue <\/b>für Felder nicht zur Verfügung steht, indem Sie das Kombinationsfeld in cboKategorieID <\/b>umbenennen und dann versuchen, dem Feld KategorieID <\/b>die Eigenschaft DefaultValue <\/b>zuzuweisen. Diese steht dort nicht zur Verfügung, wie Bild 3 zeigt.<\/p>\n Bild 3: DefaultValue steht nur für Steuerelemente zur Verfügung<\/span><\/b><\/p>\n Eine Variante lautet nun, den Wert des zuvor eingegebenen Datensatzes als Standardwert für den folgenden Datensatz zu übernehmen. Dazu ist nicht viel Aufwand nötig: Wir fügen dem Klassenmodul des Formulars lediglich eine Ereignisprozedur hinzu, die durch das Ereignis Nach Aktualisierung <\/b>des betroffenen Steuerelements ausgelöst wird. Diese Prozedur sieht wie folgt aus:<\/p>\n Wenn Sie nun den Wert des Feldes KategorieID <\/b>über das Kombinationsfeld ändern und dann einen neuen Datensatz anzeigen, erscheint der zuletzt gewählte Wert bereits als Standardwert dieses Feldes.<\/p>\n Wenn Sie diese Methode nutzen, benötigen Sie für andere Datentypen leicht abgewandelte Varianten der obigen Methode. Für Felder mit dem Datentyp Text <\/b>etwa müssen Sie den Wert, den Sie der Eigenschaft DefaultValue <\/b>zuweisen wollen, noch in Anführungszeichen einfassen. Für das Textfeld txtArtikelname <\/b>sieht dies wie folgt aus:<\/p>\n Chr(34) <\/b>entspricht dem Anführungszeichen („<\/b>). Sie können stattdessen auch zwei in zwei weitere Anführungszeichen eingefasste Anführungszeichen angeben:<\/p>\n Die Variante mit Chr(34) <\/b>ist jedoch besser lesbar.<\/p>\n Für andere Felddatentypen wie Datum<\/b>– oder Ja\/Nein<\/b>-Felder verwenden Sie auch die zuerst genannte Variante mit der direkten Zuweisung des aktuellen Wertes.<\/p>\n Damit findet der Benutzer nun schon einmal jeweils den zuletzt eingegebenen Wert für verschiedene Steuerelemente als Standardwert für neue Datensätze vor.<\/p>\n Die Lösung hat allerdings einen kleinen Nachteil: Wenn der Benutzer die Datenbank schließt und wieder öffnet, sind die zusammengestellten Standardwerte wieder weg (genau genommen geschieht dies bereits, wenn das Formular geschlossen wird). Das ist klar, denn wenn wir dynamisch per VBA Eigenschaften zuweisen, werden diese ja nicht gespeichert. Dies wäre nur der Fall, wenn Sie die Eigenschaft Standardwert <\/b>in der Entwurfsansicht festlegen und das Formular dann speichern.<\/p>\n Was tun Abhilfe schafft eine Tabelle, in welcher wir die Standardwerte für verschiedene Formulare und Steuerelemente speichern können. Die Tabelle heißt tblStandardwerte<\/b> und sieht im Entwurf wie in Bild 4 aus. Damit die Tabelle nicht nur für ein, sondern gleich für mehrere Formulare Standardwerte speichern kann, legen wir zwei Felder namens Formularename <\/b>und Steuerelementname <\/b>an, welche die entsprechenden Daten zum betroffenen Steuerelement speichern. Das Feld Standardwert <\/b>nimmt dann den zu speichernden Standardwert auf. Damit der Benutzer für keine Kombination aus Formularname und Steuerelementname zwei Standardwerte speichern kann, fügen wir gleich noch einen eindeutigen Index namens UniqueIndex <\/b>für die beiden Felder Formularname <\/b>und Steuerelementname <\/b>hinzu.<\/p>\n Bild 4: Tabelle zum Speichern von Standardwerten<\/span><\/b><\/p>\n Um unser Formular mit Funktionen zum Lesen und Schreiben der Standardwerte auszustatten, kopieren wir es zunächst und fügen es unter dem Namen frmArtikel_Standardwerttabelle<\/b> wieder ein. Werfen Sie dann die bereits angelegten Ereignisprozeduren aus der neuen Version des Formulars heraus.<\/p>\n Das Speichern eines Wertes als Standardwert soll beim Speichern des jeweiligen Datensatzes erfolgen. Dazu bauen wir uns eine Prozedur, die den Namen des Formulars, den Namen des Steuerelements und den neuen Standardwert als Parameter entgegennimmt und nennen diese StandardwertSpeichern<\/b>. Die Prozedur sieht wie in Listing 1 aus. Die Prozedur prüft zunächst, ob der Parameter varStandardwert <\/b>überhaupt einen Wert enthält. Falls das Feld, für das der Standardwert gespeichert werden soll, nämlich den Wert Null <\/b>hat, ist varStandardwert <\/b>leer. Ist varStandardwert leer, geschieht Folgendes:<\/p>\n Listing 1: Prozedur zum Speichern von Standardwerten<\/span><\/b><\/p>\n Die Prozedur versucht, einen neuen Datensatz in der Tabelle tblStandardwerte <\/b>anzulegen. Dabei sollen die mit den drei Parametern strFormularname<\/b>, strSteuerelementname <\/b>und varStandardwert <\/b>übergebenen Werte in die drei Felder Formularname<\/b>, Steuerelementname <\/b>und Standardwert <\/b>der Tabelle tblStandardwerte <\/b>eingetragen werden. Für den dritten Parameter haben wir den Datentyp Variant <\/b>gewählt, damit hier auch der Wert Null <\/b>verarbeitet werden kann.<\/p>\n Da es beim Speichern geschehen kann, dass die Prozedur versucht, einen Datensatz mit einer bereits vorhandenen Kombination aus Formularname und Steuerelementname zu speichern, haben wir zuvor die eingebaute Fehlerbehandlung deaktiviert.<\/p>\n <\/p>\n So meldet Access keinen Fehler, wenn das Anlegen des Datensatzes aus dem genannten Grund fehlschlägt. Stattdessen prüft die Prozedur anschließend, ob der Fehler mit der Nummer 3022 <\/b>aufgetreten ist, was diesem Fehler entspricht. In diesem Fall soll die Prozedur dann den Wert des Feldes Standardwert <\/b>in dem bereits vorhandenen Datensatz überschreiben.<\/p>\n Sollte varStandardwert <\/b>leer sein, dann legt die Prozedur auch einen Datensatz in der Tabelle tblStandardwerte <\/b>an beziehungsweise ändert den Standardwert für einen eventuell vorhandenen Datensatz für diese Konstellation aus Formularname und Steuerelementname. Allerdings trägt die Prozedur dann den Wert NULL <\/b>für das Feld Standardwert <\/b>ein.<\/p>\n In der Nach Aktualisierung<\/b>-Ereignisprozedur des Formulars tragen wir dann etwa die folgende Zeile ein, um den aktuellen Wert des Feldes cboKategorieID <\/b>in der Tabelle tblStandardwerte <\/b>zu speichern:<\/p>\n Nachdem Sie nun einen Datensatz im Formular frmArtikel_Standardwerttabelle <\/b>bearbeitet haben, speichert diese Prozedur den dabei verwendeten Wert für das Steuerelement cboKategorien <\/b>wie in Bild 5 in der Tabelle tblStandardwerte<\/b>.<\/p>\n Bild 5: Tabelle zum Speichern von Standardwerten, Datenblattansicht<\/span><\/b><\/p>\n Nun benötigen wir noch einen Algorithmus, der die Standardwerte wiederherstellt. Hier wollen wir nicht so kleinschrittig vorgehen und eine Prozedur bereitstellen, die für jeden vorzugebenden Wert erneut aufgerufen wird. Stattdessen wollen wir der zu erstellenden Prozedur nur noch den Namen des Formulars übergeben, dessen Standardwerte eingestellt werden sollen, den Rest soll die Prozedur anhand der für dieses Formular gespeicherten Werte erledigen.<\/p>\n Die dazu verwendete Prozedur finden Sie in Listing 2. Die Prozedur erwartet diesmal nicht den Namen des zu behandelnden Formulars, sondern gleich einen Verweis auf das Formular-Objekt selbst. Das hat den Hintergrund, dass wir in der Prozedur sowieso noch auf Elemente des Formulars zugreifen wollen – also können wir auch direkt den Objektverweis darauf übergeben. Die Prozedur öffnet ein Recordset auf Basis der Tabelle tblStandardwerte<\/b>, wobei nur diejenigen Datensätze berücksichtigt werden, deren Formularname dem Namen des mit frm <\/b>übergebenen Formulars entsprechen.<\/p>\n Listing 2: Prozedur zum Setzen von Standardwerten<\/span><\/b><\/p>\n Dies durchläuft die Prozedur in einer Schleife und trägt dabei für alle gefundenen Datensätze den im Feld Standardwert <\/b>angegebenen Wert in das im Feld Steuerelementname <\/b>gefundene Steuerelement ein. Diese Methode rufen wir nur dann auf, wenn der Benutzer einen neuen Datensatz anlegt. Dies fangen wir in der Ereignisprozedur ab, die durch das Ereignis Beim Anzeigen <\/b>ausgelöst wird und die wie folgt aussieht:<\/p>\n Wie Sie sehen, prüfen wir hier die Eigenschaft NewRecord<\/b>, die nur dann den Wert True <\/b>aufweist, wenn das Formular gerade einen neuen, leeren Datensatz anzeigt. Ist dies der Fall, ruft die Prozedur die Routine StandardwerteSetzen<\/b> auf und übergibt mit Me <\/b>den Verweis auf das aktuelle Formular. Die Routine StandardwerteSetzen <\/b>trägt nun die Standardwerte für die Steuerelemente ein.<\/p>\n Nun wollen wir neben der Kategorie auch noch ein Textfeld mit einem dynamischen Standardwert ausstatten. Dazu fügen wir der Prozedur Form_AfterUpdate <\/b>noch eine weitere Zeile hinzu:<\/p>\n Auch diese Werte werden nach der änderung an einem Datensatz wie geplant in die Tabelle tblStandardwerte <\/b>geschrieben. Beim anschließenden Neuanlegen eines Datensatzes erhalten wir allerdings wie in Bild 6 im Textfeld txtArtikelname <\/b>den Wert #Name<\/b>.<\/p>\n Bild 6: Das Zuweisen des Standardwertes für den Artikelnamen funktioniert nicht.<\/span><\/b><\/p>\n Warum das Wir haben eines übersehen, was wir Eingangs bereits erwähnt haben: Wenn Sie Standardwerte für Felder mit dem Datentyp Text <\/b>angeben wollen, müssen diese in Anführungszeichen eingefasst werden. Damit haben Sie nun auch ein Bild davon, was geschieht, wenn man diese Eigenheit nicht beachtet. Interessanterweise können wir nach dem Zuweisen der Werte für die DefaultValue<\/b>-Eigenschaft sogar den Wert im Direktbereich ausgeben und erhalten den vorgesehenen Wert für das Feld txtArtikelname<\/b>:<\/p>\n Aber wir erhalten dennoch #Name <\/b>im Textfeld selbst. Leider liefert die Zuweisung ohne Anführungszeichen auch keinen Fehler, auf den wir reagieren könnten, indem wir den Text dann einfach in Anführungszeichen setzen und erneut übergeben.<\/p>\n Aber dem können wir vorbeugen: Wir passen einfach die Prozedur StandardwerteSetzen <\/b>wie in Listing 3 an. Innerhalb der Do While<\/b>-Schleife über alle Datensätze zum aktuellen Formular fragen wir mit einer Select Case<\/b>-Bedingung den Datentyp des Feldes ab, das hinter dem jeweiligen Steuerelement steckt. Der dazu untersuchte Ausdruck lautet frm.Recordset.Fields(frm.Con-trols(rst!Steuer-ele-ment-name).ControlSource).Type<\/b>.<\/p>\n Listing 3: Neue Version der Prozedur StandardwerteSetzen, die auch Felder mit dem Datentyp Text korrekt behandelt<\/span><\/b><\/p>\n Von innen nach außen liefert rst!Steuerelementname <\/b>den Namen des aktuell zu füllenden Steuerelements aus der Tabelle tblStandardwerte<\/b>. Die Auflistung frm.Controls <\/b>für dieses Element liefert das Steuerelement, das an dieses Feld gebunden ist. Dieses wiederum finden wir auch in dem Recordset <\/b>wieder, das an das Formular gebunden ist. Und das Recordset <\/b>enthält für jedes Feld Eigenschaften wie etwa Type <\/b>für den Datentyp. Hat diese nun den Wert 10<\/b>, also die Konstante dbText<\/b>, dann soll die Spezialbehandlung mit den einfassenden Anführungszeichen durchgeführt werden. Dies gelingt wie gewünscht, mit der neuen Version zeigt das Formular alle Werte wie in der Tabelle tblStandardwerte <\/b>gespeichert an (s. Bild 8).<\/p>\n Bild 7: Die Tabelle tblStandardwerte mit allen Werten eines Artikel-Datensatzes<\/span><\/b><\/p>\n Es gibt noch einen zweiten Sonderfall, nämlich Datumswerte. Dazu haben wir auch einen Case<\/b>-Zweig eingerichtet, der aus dem im Feld Standardwert <\/b>gespeicherten Datumswert erst ein Datum ermittelt und dieses dann in eine Double<\/b>-Zahl konvertiert. Diese wird dann im Datumsfeld AufgenommenAm <\/b>wieder wie ein Datum angezeigt (Double <\/b>ist ohnehin der interne Datentyp für das Speichern von Datumswerten):<\/p>\n Wenn Sie dieses für alle Felder eines Formulars einrichten wollen, können Sie dies mit einer Prozedur wie der aus Listing 4 erledigen. <\/p>\n Listing 4: Diese Prozedur speichert den aktuell bearbeiteten Datensatz in der Tabelle tblStandardwerte.<\/span><\/b><\/p>\n Das Ergebnis sieht wie gewünscht aus (s. Bild 7). Sie sehen dort einen komplett neuen Datensatz, der vollständig mit Standardwerten gefüllt wurde. Das erkennen Sie daran, dass das Feld mit dem Primärschlüsselwert noch den Wert (Neu) <\/b>anzeigt.<\/p>\n Bild 8: Ein neuer, komplett mit Standardwerten gefüllter Datensatz<\/span><\/b><\/p>\n An dieser Stelle müssen wir auch auf die Gefahr hinweisen, die bei vollständig mit Standardwerten gefüllten Formularen drohen: Wenn der Benutzer ein solches Formular öffnet, den Datensatz für okay befindet, weil er alle Daten wie gewünscht enthält (zugegeben: bei einem Artikel ist das nicht unbedingt wahrscheinlich) und das Formular dann schließt, wird der neue Datensatz nicht gespeichert. Dies geschieht erst, wenn der Benutzer zuvor zumindest ein Feld bearbeitet hat. Erst dann wird der Datensatz als „in Bearbeitung“ markiert und der Datensatz wird beim Schließen des Formulars gespeichert.<\/p>\n Wenn Sie in einer Situation, in der der Benutzer gerade zu einem neuen, leeren Datensatz geblättert hat, eine Rückfrage beim Schließen des Formulars einbauen wollen, können Sie dies als Ereignisprozedur für das Ereignis Beim Entladen <\/b>erledigen.<\/p>\n In diesem Ereignis können Sie durch Setzen des Parameters Cancel <\/b>auf den Wert True <\/b>verhindern, dass das Formular geschlossen wird. Die Prozedur sieht so wie in Listing 5 aus.<\/p>\n Listing 5: Rückfrage beim Schließen des Formulars mit einem neuen Datensatz<\/span><\/b><\/p>\n Nach der Prüfung, ob es sich um einen neuen Datensatz handelt (Me.NewRecord<\/b>), fragt die Prozedur, ob der frisch angelegte Datensatz verworfen werden soll (s. Bild 9). Falls der Benutzer auf Ja <\/b>klickt, wird das Formular geschlossen. Anderenfalls bleibt das Formular geöffnet und gibt dem Benutzer die Gelegenheit, doch noch etwas aus dem neuen Datensatz zu machen.<\/p>\n Bild 9: Rückfrage, ob der Datensatz gespeichert werden soll<\/span><\/b><\/p>\n Falls der Benutzer nicht versteht, dass er zumindest eine änderung an diesem Datensatz durchführen muss, könnten Sie zusätzlich noch die folgende Zeile innerhalb der inneren If…Then<\/b>-Bedingung unterbringen. Die erste Zeile setzt den Fokus auf eines der Steuerelemente im Formular, was Voraussetzung für das Versetzen in den Bearbeitungszustand mit Me.Dirty = True <\/b>ist:<\/p>\n Bisher müssen Sie noch für jedes Steuerelement, dessen Inhalt als Standardwert gespeichert werden soll, den Inhalt mit einer Zeile wie der folgenden per Code erfassen:<\/p>\n Das wollen wir so ändern, dass Sie die Steuerelemente, die beim Speichern der Standardwerte berücksichtigt werden sollten, einfach mit einem bestimmten Wert in der Eigenschaft Marke <\/b>(VBA: Tag<\/b>) markieren. Dann brauchen Sie nur noch den folgenden Einzeiler zum Ereignis Form_AfterUpdate <\/b>des betroffenen Formular hinzuzufügen:<\/p>\n Den Aufruf der Prozedur StandardwertSpeichern<\/b> lagern wir für die markierten Steuerelemente dann wie in der Prozedur aus Listing 6 aus. Die Prozedur erwartet nur einen Objektverweis auf das zu untersuchende Formular. Es durchläuft in einer For Each<\/b>-Schleife alle Steuerelemente des Formulars und untersucht sie dahingehend, ob die Eigenschaft Tag <\/b>den Wert DefaultValue <\/b>enthält. Falls ja, ruft sie für dieses Steuerelement die Prozedur StandardwertSpeichern<\/b> auf und übergibt den Formularnamen, den Steuerelementnamen sowie den aktuellen Wert.<\/p>\n Listing 6: Diese Prozedur durchläuft alle markierten Steuerelemente und speichert die Standardwerte.<\/span><\/b><\/p>\n Die Eigenschaft Marke <\/b>stellen Sie über die Entwurfsansicht des Formulars ein, indem Sie auf das betroffene Steuerelement klicken und im Eigenschaftsfenster in den Bereich Andere <\/b>zur Eigenschaft Marke <\/b>wechseln (s. Bild 10). Auf diese Weise landen nur die Werte der Steuerelemente, die Sie dafür vorgesehen haben, als Standardwerte in der Tabelle tblStandardwerte<\/b>.<\/p>\n![\"Kategorie](\"..\/fileadmin\/_temp_\/2016_05\/pic_1052_002.png\")
<\/p>\nVorarbeit: Steuerelementname ändern<\/h2>\n
![\"DefaultValue](\"..\/fileadmin\/_temp_\/2016_05\/pic_1052_003.png\")
<\/p>\nWert des vorherigen Datensatzes übernehmen<\/h2>\n
Private Sub <\/span>cboKategorieID_AfterUpdate()\r\n Me!cboKategorieID.DefaultValue = Me!cboKategorieID\r\nEnd Sub<\/span><\/pre>\nPrivate Sub <\/span>txtArtikelname_AfterUpdate()\r\n Me!txtArtikelname.DefaultValue = Chr(34) _\r\n & Me!txtArtikelname & Chr(34)\r\nEnd Sub<\/span><\/pre>\nMe!txtArtikelname.DefaultValue = \"\"\"\" _\r\n & Me!txtArtikelname & \"\"\"\"<\/pre>\n
Nach dem Schließen und öffnen<\/h2>\n
![\"Tabelle](\"..\/fileadmin\/_temp_\/2016_05\/pic_1052_004.png\")
<\/p>\nStandardwerte speichern<\/h2>\n
Public Sub <\/span>StandardwertSpeichern(strFormularname As String<\/span>, strSteuerelementname As String<\/span>, varStandardwert As Variant<\/span>)\r\n Dim <\/span>db As <\/span>DAO.Database\r\n Set<\/span> db = CurrentDb\r\n On Error Resume Next<\/span>\r\n If <\/span>Not<\/span> IsEmpty(varStandardwert) Then<\/span>\r\n db.Execute \"INSERT INTO tblStandardwerte(Formularname, Steuerelementname, Standardwert) VALUES(''''\" _\r\n & strFormularname & \"'''', ''''\" & strSteuerelementname & \"'''', ''''\" & varStandardwert & \"'''')\", dbFailOnError\r\n If <\/span>Err.Number = 3022 Then<\/span>\r\n db.Execute \"UPDATE tblStandardwerte SET Standardwert = ''''\" & varStandardwert & \"'''' WHERE Formularname = ''''\" _\r\n & strFormularname & \"'''' AND Steuerelementname = ''''\" & strSteuerelementname & \"''''\", dbFailOnError\r\n End If<\/span>\r\n Else<\/span>\r\n db.Execute \"INSERT INTO tblStandardwerte(Formularname, Steuerelementname, Standardwert) VALUES(''''\" _\r\n & strFormularname & \"'''', ''''\" & strSteuerelementname & \"'''', NULL)\", dbFailOnError\r\n If <\/span>Err.Number = 3022 Then<\/span>\r\n db.Execute \"UPDATE tblStandardwerte SET Standardwert = NULL WHERE Formularname = ''''\" & strFormularname _\r\n & \"'''' AND Steuerelementname = ''''\" & strSteuerelementname & \"''''\", dbFailOnError\r\n End If<\/span>\r\n End If<\/span>\r\nEnd Sub<\/span><\/pre>\nPrivate Sub <\/span>Form_AfterUpdate()\r\n StandardwertSpeichern Me.Name, \"cboKategorieID\", _\r\n Me!cboKategorieID\r\nEnd Sub<\/span><\/pre>\n![\"Tabelle](\"..\/fileadmin\/_temp_\/2016_05\/pic_1052_005.png\")
<\/p>\nStandardwerte wiederherstellen<\/h2>\n
Public Sub <\/span>StandardwerteSetzen(frm As <\/span>Form)\r\n Dim <\/span>db As <\/span>DAO.Database\r\n Dim <\/span>rst As <\/span>DAO.Recordset\r\n Set<\/span> db = CurrentDb\r\n Set<\/span> rst = db.OpenRecordset(\"SELECT * FROM tblStandardwerte WHERE Formularname = ''''\" & frm.Name & \"''''\", dbOpenDynaset)\r\n On Error Resume Next<\/span>\r\n Do While<\/span> Not<\/span> rst.EOF\r\n frm.Controls(rst!Steuerelementname).DefaultValue = rst!Standardwert\r\n rst.MoveNext<\/span>\r\n Loop<\/span>\r\n On Error GoTo<\/span> 0\r\nEnd Sub<\/span><\/pre>\nPrivate Sub <\/span>Form_Current()\r\n If <\/span>Me.NewRecord Then<\/span>\r\n StandardwerteSetzen Me\r\n End If<\/span>\r\nEnd Sub<\/span><\/pre>\nStandardwerte erweitern<\/h2>\n
Private Sub <\/span>Form_AfterUpdate()\r\n StandardwertSpeichern Me.Name, \"cboKategorieID\", _\r\n Me!cboKategorieID\r\n StandardwertSpeichern _\r\n Me.Name, _\r\n \"txtArtikelname\", _\r\n Me!txtArtikelname\r\nEnd Sub<\/span><\/pre>\n![\"Das](\"..\/fileadmin\/_temp_\/2016_05\/pic_1052_006.png\")
<\/p>\nfrm.Controls(rst!Steuerelementname).DefaultValue = _\r\n rst!Standardwert\r\nDebug.Print<\/span> rst!Steuerelementname, _\r\n frm.Controls(rst!Steuerelementname).DefaultValue<\/pre>\nPublic Sub <\/span>StandardwerteSetzen(frm As <\/span>Form)\r\n Dim <\/span>db As <\/span>DAO.Database\r\n Dim <\/span>rst As <\/span>DAO.Recordset\r\n Set<\/span> db = CurrentDb\r\n Set<\/span> rst = db.OpenRecordset(\"SELECT * FROM tblStandardwerte WHERE Formularname = ''''\" & frm.Name & \"''''\", dbOpenDynaset)\r\n On Error Resume Next<\/span>\r\n Do While<\/span> Not<\/span> rst.EOF\r\n If <\/span>Not<\/span> IsNull(rst!Standardwert) Then<\/span>\r\n Select Case frm.Recordset.Fields(frm.Controls(rst!Steuerelementname).ControlSource).Type\r\n Case <\/span>dbText\r\n frm.Controls(rst!Steuerelementname).DefaultValue = Chr(34) & rst!Standardwert & Chr(34)\r\n Case <\/span>dbDate\r\n frm.Controls(rst!Steuerelementname).DefaultValue = CDbl(CDate(rst!Standardwert))\r\n Case Else<\/span>\r\n frm.Controls(rst!Steuerelementname).DefaultValue = rst!Standardwert\r\n End Select<\/span>\r\n Else<\/span>\r\n frm.Controls(rst!Steuerelementname).DefaultValue = Null\r\n End If<\/span>\r\n rst.MoveNext<\/span>\r\n Loop<\/span>\r\n On Error GoTo<\/span> 0\r\nEnd Sub<\/span><\/pre>\n![\"Die](\"..\/fileadmin\/_temp_\/2016_05\/pic_1052_008.png\")
<\/p>\nfrm.Controls(rst!Steuerelementname).DefaultValue = _\r\n CDbl(CDate(rst!Standardwert))<\/pre>\n
Standardwerte für alle Felder<\/h2>\n
Private Sub <\/span>Form_AfterUpdate()\r\n StandardwertSpeichern Me.Name, \"txtArtikelname\", Nz(Me!txtArtikelname)\r\n StandardwertSpeichern Me.Name, \"cboKategorieID\", Nz(Me!cboKategorieID)\r\n StandardwertSpeichern Me.Name, \"cboLieferantID\", Nz(Me!cboLieferantID)\r\n StandardwertSpeichern Me.Name, \"txtLiefereinheit\", Nz(Me!txtLiefereinheit)\r\n StandardwertSpeichern Me.Name, \"txtEinzelpreis\", Nz(Me!txtEinzelpreis)\r\n StandardwertSpeichern Me.Name, \"txtLagerbestand\", Nz(Me!txtLagerbestand)\r\n StandardwertSpeichern Me.Name, \"txtBestellteEinheiten\", Nz(Me!txtBestellteEinheiten)\r\n StandardwertSpeichern Me.Name, \"txtMindestbestand\", Nz(Me!txtMindestbestand)\r\n StandardwertSpeichern Me.Name, \"chkAuslaufartikel\", Nz(Me!chkAuslaufartikel)\r\n StandardwertSpeichern Me.Name, \"txtAufgenommenAm\", Nz(Me!txtAufgenommenAm)\r\nEnd Sub<\/span><\/pre>\n![\"Ein](\"..\/fileadmin\/_temp_\/2016_05\/pic_1052_007.png\")
<\/p>\nPrivate Sub <\/span>Form_Unload(Cancel As Integer<\/span>)\r\n If <\/span>Me.NewRecord Then<\/span>\r\n If MsgBox<\/span>(\"Neu angelegten Datensatz verwerfen\", vbYesNo, \"Neuer Datensatz\") _\r\n = vbNo Then\r\n Cancel = True<\/span>\r\n End If<\/span>\r\n End If<\/span>\r\nEnd Sub<\/span><\/pre>\n![\"Rückfrage,](\"..\/fileadmin\/_temp_\/2016_05\/pic_1052_009.png\")
<\/p>\nMe!txtArtikelname.SetFocus\r\nMe.Dirty = True<\/span><\/pre>\nStandardwert-Felder per Tag markieren<\/h2>\n
StandardwertSpeichern Me.Name, \"txtArtikelname\", _\r\n Nz(Me!txtArtikelname)<\/pre>\n
Private Sub <\/span>Form_AfterUpdate()\r\n StandardwerteSpeichernMarke Me\r\nEnd Sub<\/span><\/pre>\nPublic Sub <\/span>StandardwerteSpeichernMarke(frm As <\/span>Form)\r\n Dim <\/span>ctl As <\/span>Control\r\n For Each ctl In frm.Controls\r\n If <\/span>ctl.Tag = \"DefaultValue\" Then<\/span>\r\n StandardwertSpeichern frm.Name, ctl.Name, ctl.Value\r\n End If<\/span>\r\n Next<\/span> ctl\r\nEnd Sub<\/span><\/pre>\n![\"Einstellen](\"..\/fileadmin\/_temp_\/2016_05\/pic_1052_010.png\")
<\/p>\n