{"id":55001085,"date":"2017-06-01T00:00:00","date_gmt":"2020-05-14T13:42:27","guid":{"rendered":"http:\/\/access-im-unternehmen.aix-dev.de\/aiu\/?p=1085"},"modified":"-0001-11-30T00:00:00","modified_gmt":"-0001-11-30T00:00:00","slug":"Datensatzaenderungen_auf_einen_Blick","status":"publish","type":"post","link":"https:\/\/access-im-unternehmen.de\/Datensatzaenderungen_auf_einen_Blick\/","title":{"rendered":"Datensatzänderungen auf einen Blick"},"content":{"rendered":"

\"\"<\/p>\n

Wenn der Benutzer änderungen an den in einem Formular angezeigten Daten vornimmt, sieht er nur noch die geänderten Daten. Was aber, wenn er beispielsweise einen Wert in ein falsches Feld eingetragen hat – zum Beispiel indem er Vorname und Nachname vertauscht Dann möchte er die änderung vermutlich rückgängig machen. Aber wie, wenn er den vorherigen Wert nicht mehr in Erinnerung hat Also erleichtern wir ihm die Arbeit, indem wir die alten Werte neben den entsprechenden Textfeldern anzeigen.<\/b><\/p>\n

Die hier vorgestellte Technik bezieht sich natürlich auf Detailformulare – in der Datenblatt- oder Endlosansicht lassen sich Steuerelemente zur Anzeige der vorherigen Daten nur schlecht anzeigen. Wir beginnen also mit einem neuen, leeren Formular namens frmDatensatz-aenderungenAufEinenBlick<\/b>, dessen Eigenschaft Datenherkunft <\/b>wir mit dem Namen der Tabelle tblKunden <\/b>füllen.<\/p>\n

Diese finden Sie bereits in der Beispieldatenbank.<\/p>\n

Anschließend können Sie alle Felder dieser Tabelle aus der Feldliste in den Detailbereich der Entwurfsansicht des Formulars ziehen. Das Ergebnis sieht etwa wie in Bild 1 aus.<\/p>\n

\"Entwurf<\/p>\n

Bild 1: Entwurf des Ausgangsformulars<\/span><\/b><\/p>\n

Damit das Formular die alten Werte der jeweiligen Felder anzeigen kann, fügen wir für jedes Feld, das der Benutzer bearbeiten kann, ein weiteres Textfeld samt Bezeichnungsfeld hinzu. Die Bezeichnungsfelder erhalten jeweils den Text Alt: <\/b>als Beschriftung. Die Textfelder benennen wir genauso wie die eigentlichen Textfelder – mit dem Unterschied, dass wir den Namen noch das Suffix _Alt <\/b>anhängen. Das Textfeld zur Anzeige des alten Wertes für das Feld txtVorname <\/b>soll also txtVorname_Alt <\/b>heißen (s. Bild 2).<\/p>\n

\"Anlegen<\/p>\n

Bild 2: Anlegen der Textfelder für die alten Werte<\/span><\/b><\/p>\n

Hier haben wir nun bereits den Wert Aktiviert <\/b>der Textfelder mit den vorherigen Werten auf Nein <\/b>eingestellt, damit der Benutzer gleich erkennen kann, dass er hier keine Werte eingeben kann.<\/p>\n

Es fehlt noch eine Einstellung, denn die Textfelder sollen ja auch erst angezeigt werden, wenn der Benutzer einen anderen als den vorhandenen Wert eingegeben hat.<\/p>\n

Also stellen wir die Eigenschaft Sichtbar<\/b> für die Textfelder auf der rechten Seite auf Nein <\/b>ein (Sie können alle Textfelder markieren, indem Sie einen Rahmen aufziehen und dann die Eigenschaft für alle Textfelder gleichzeitig einstellen).<\/p>\n

Das Formular sieht nun in der Formularansicht vorerst wie in Bild 3 aus. Beim ändern eines der Einträge tut sich natürlich noch nichts, denn wir haben ja auch noch keinen entsprechenden Code hinterlegt.<\/p>\n

\"Formular<\/p>\n

Bild 3: Formular in der Formularansicht<\/span><\/b><\/p>\n

Code zum Einblenden und Füllen der Alt-Felder<\/h2>\n

Nun haben wir uns das so vorgestellt, dass wir einfach das Ereignis Bei Geändert <\/b>für das jeweilige Steuerelement implementieren und dafür die folgende Ereignisprozedur hinterlegen:<\/p>\n

Private Sub <\/span>txtFirma_Dirty(Cancel As Integer<\/span>)\r\n     With<\/span> Me!txtFirma_Alt\r\n         .Visible = True<\/span>\r\n         .Value = Me!txtFirma.OldValue\r\n     End With<\/span>\r\nEnd Sub<\/span><\/pre>\n
Für das Feld txtFirma <\/b>soll also eine Prozedur ausgelöst werden, welche die Eigenschaft Visible <\/b>des Textfeldes txtFirma_Alt <\/b>auf True <\/b>einstellt und den Wert des Textfeldes txtFirma_Alt <\/b>auf den alten Wert (OldValue<\/b>) des Textfeldes txtFirma<\/b>.<\/p>\n
Dies klappt allerdings nicht wie gewünscht: Sobald Sie etwa ein Zeichen an den Inhalt des Textfeldes txtFirma <\/b>anfügen wollen (also ohne diesen zu markieren und zu überschreiben), werden zwar die gewünschten Aktionen für das Textfeld txtFirma_Alt <\/b>durchgeführt, aber der Inhalt des Textfeldes txtFirma <\/b>wird komplett durch das soeben eingegebene Zeichen überschrieben (s. Bild 4).<\/p>\n
\"Verhalten<\/p>\n
Bild 4: Verhalten bei Eingabe in ein Textfeld<\/span><\/b><\/p>\n
Schauen wir uns an, was zu diesem unerwarteten Verhalten führt. Ein kurzer Test, bei dem wir erst die erste, dann die zweite Anweisung innerhalb der Prozedur ausblenden, zeigt, dass die Zuweisung des alten Wertes an die Value<\/b>-Eigenschaft von txtFirma_Alt <\/b>dafür sorgt, dass der alte Wert von txtFirma <\/b>komplett überschrieben wird.<\/p>\n
Hier geschieht Folgendes: Wenn Sie das erste Zeichen in das Textfeld txtFirma <\/b>eingeben, wird bereits die Prozedur txtFirma_Dirty <\/b>ausgelöst. Das Textfeld txtFirma_Alt <\/b>wird eingeblendet und erhält als Wert den alten Wert des auslösenden Textfeldes. Bei einer solchen Zuweisung wird immer auch der Fokus auf das aufnehmende Feld verschoben!<\/p>\n
Der Fokus gelangt dann zwar wieder zum Feld txtFirma <\/b>zurück, aber beim Eintritt in das Feld wird die Markierung so eingestellt, wie dies standardmäßig beim Eintritt in ein Feld vorgesehen ist.<\/p>\n
Cursorverhalten bei Eintritt in Feld<\/h2>\n
Dieses Verhalten wird normalerweise Access-weit eingestellt, und zwar in den Optionen von Access. Hier finden Sie im Bereich Clienteinstellungen <\/b>unter Bearbeiten <\/b>die Eigenschaft Cursorverhalten bei Eintritt in Feld <\/b>(s. Bild 5).<\/p>\n
\"Option<\/p>\n
Bild 5: Option zum Einstellen des Verhaltens beim Eintritt in ein Feld<\/span><\/b><\/p>\n
Der Standardwert ist Ganzes Feld markieren<\/b>, was hier auch geschehen ist und das beobachtete Verhalten verursacht (sollten Sie eine andere Einstellung vorfinden, haben Sie auch ein entsprechendes anderes Verhalten beobachten können).<\/p>\n
Wie können wir nun den Inhalt des Feldes transferieren, ohne dass nach dem Zurücksetzen des Fokus auf das auslösende Feld wieder der komplette Inhalt markiert und ersetzt wird Hilft es eventuell, wenn wir die Einstellung für diese Aktion per Code ändern Wohl kaum, denn wir wissen ja nicht, an welcher Stelle der Benutzer die änderung durchgeführt hat. <\/p>\n
Die einzige Möglichkeit, die wir haben, ist, uns die aktuelle  Cursorposition zu merken und die Länge der Markierung und die Position vor der Rückkehr des Fokus zum auslösenden Feld wiederherzustellen.<\/p>\n
Dies erledigen wir, indem wir zunächst zwei Variablen zur Prozedur hinzufügen, mit denen wir die Position der Einfügemarke sowie die Breite der Markierung speichern. Dann füllen wir diese beiden Variablen mit den entsprechenden Werten für das Textfeld txtFirma<\/b>. Anschließend folgen die bereits vorhandenen Anweisungen der Prozedur. Nach dem Verschieben des Fokus auf das Textfeld txtFirma_Alt <\/b>und vor dem Erhalt des Fokus durch das Textfeld txtFirma <\/b>stellen wir die Markierungsposition und -breite wieder her:<\/p>\n
Private Sub <\/span>txtFirma_Dirty(Cancel As Integer<\/span>)\r\n     Dim <\/span>lngSelStart As Long<\/span>\r\n     Dim <\/span>lngSelLength As Long<\/span>\r\n     lngSelStart = Me!txtFirma.SelStart\r\n     lngSelLength = Me!txtFirma.SelLength\r\n     With<\/span> Me!txtFirma_Alt\r\n         .Visible = True<\/span>\r\n         .Value = Me!txtFirma.OldValue\r\n     End With<\/span>\r\n     Me!txtFirma.SelStart = lngSelStart\r\n     Me!txtFirma.SelLength = lngSelLength\r\nEnd Sub<\/span><\/pre>\n
Nun erhalten wir das gewünschte Verhalten, wie Bild 6 zeigt. Wir haben hier den Buchstaben n <\/b>aus dem Firmennamen gelöscht, der anschließend genau wie erwartet angezeigt wird.<\/p>\n
\"Gewünschtes<\/p>\n
Bild 6: Gewünschtes Verhalten<\/span><\/b><\/p>\n
übrige Felder mit Funktionalität ausstatten<\/h2>\n
Nun wollen wir noch schnell die übrigen Felder mit der hier implementierten Funktion ausstatten. Dazu legen Sie einfach die leeren Prozeduren für das Ereignis Bei Geändert <\/b>an und kopieren den Inhalt der weiter oben bereits vorgestellten Prozedur für das Feld txtFirma <\/b>ein.<\/p>\n
Außerdem passen Sie dort noch die Feldnamen an, indem Sie etwa für das Textfeld txtVorname <\/b>jeweils txtFirma <\/b>durch txtVorname <\/b>und txtFirma_Alt <\/b>durch txtVorname_Alt <\/b>ersetzen:<\/p>\n
Private Sub <\/span>txtVorname_Dirty(Cancel As Integer<\/span>)\r\n     Dim <\/span>lngSelStart As Long<\/span>\r\n     Dim <\/span>lngSelLength As Long<\/span>\r\n     lngSelStart = Me!txtVorname.SelStart\r\n     lngSelLength = Me!txtVorname.SelLength\r\n     With<\/span> Me!txtVorname_Alt\r\n         .Visible = True<\/span>\r\n         .Value = Me!txtVorname.OldValue\r\n     End With<\/span>\r\n     Me!txtVorname.SelStart = lngSelStart\r\n     Me!txtVorname.SelLength = lngSelLength\r\nEnd Sub<\/span><\/pre>\n
Dies müssen Sie nun nur noch für alle übrigen Felder durchführen und erhalten so einen sehr gut wartbaren Code. äh … nein, doch nicht. Genau genommen haben wir nun eine ganze Reihe von Prozeduren erstellt, die alle das gleiche tun – mit dem Unterschied, dass jeweils zwei andere Textfelder referenziert werden.<\/p>\n
Code optimieren<\/h2>\n
Eine erste Möglichkeit, den Code zumindest zuverlässiger vervielfältigen zu können, ist die folgende Variante, die wir für das Ereignis Bei änderung <\/b>des Textfeldes txtNachname <\/b>implementiert haben:<\/p>\n
Private Sub <\/span>txtNachname_Dirty(Cancel As Integer<\/span>)\r\n     Dim <\/span>lngSelStart As Long<\/span>\r\n     Dim <\/span>lngSelLength As Long<\/span>\r\n     Dim <\/span>strTextfeld As String<\/span>\r\n     strTextfeld = \"txtNachname\"\r\n     lngSelStart = Me(strTextfeld).SelStart\r\n     lngSelLength = Me(strTextfeld).SelLength\r\n     With<\/span> Me(strTextfeld & \"_Alt\")\r\n         .Visible = True<\/span>\r\n         .Value = Me(strTextfeld).OldValue\r\n     End With<\/span>\r\n     Me(strTextfeld).SelStart = lngSelStart\r\n     Me(strTextfeld).SelLength = lngSelLength\r\nEnd Sub<\/span><\/pre>\n
<\/p>\n
Hier haben wir den Namen des betroffenen Textfeldes, nämlich txtNachname<\/b>, in einer Variablen namens strTextfeld <\/b>gespeichert. Danach haben wir alle Bezüge auf dieses Steuerelement in der Prozedur, die etwa Me!txtNachname <\/b>lauten, in Me(strTextfeld) <\/b>geändert. Für die Stellen, an denen es eine Referenz auf Me!txtNachname_Alt <\/b>gibt, verwenden wir Me(strTextfeld & „_Alt“)<\/b>.<\/p>\n
Hier profitieren wir also davon, dass wir die Textfelder zum Anzeigen der alten Werte immer konsequent mit dem Suffix _Alt <\/b>ausgestattet haben.<\/p>\n
Wir können den Inhalt der Prozedur nun also in die entsprechenden Prozeduren der übrigen Steuerelemente übertragen und brauchen nur noch die Zeile strTextfeld = „txtNachname“ <\/b>an den Namen des jeweils aufrufenden Textfeldes anzupassen. Die Gefahr, beim Copy and Paste und beim anschließenden manuellen Anpassen Fehler in den Code einzubauen, sinkt so erheblich.<\/p>\n
Ausgliedern in Funktion<\/h2>\n
Wir können den Code aber noch weiter vereinfachen – nämlich indem wir eine Prozedur anlegen, die den Namen des Textfeldes als Parameter erwartet und dann die Daten der Markierung des übergebenen Textfeldes speichert, den alten Wert an das änderungstextfeld übergibt und die Einfügemarkierung wieder herstellt:<\/p>\n
Private Sub <\/span>Textbox_Dirty(strTextfeld As String<\/span>)\r\n     Dim <\/span>lngSelStart As Long<\/span>\r\n     Dim <\/span>lngSelLength As Long<\/span>\r\n     lngSelStart = Me(strTextfeld).SelStart\r\n     lngSelLength = Me(strTextfeld).SelLength\r\n     With<\/span> Me(strTextfeld & \"_Alt\")\r\n         .Visible = True<\/span>\r\n         .Value = Me(strTextfeld).OldValue\r\n     End With<\/span>\r\n     Me(strTextfeld).SelStart = lngSelStart\r\n     Me(strTextfeld).SelLength = lngSelLength\r\nEnd Sub<\/span> <\/pre>\n
Den Aufruf dieser Funktion tragen wir beispielsweise in die Bei änderung<\/b>-Ereignisprozedur für das Textfeld txtOrt <\/b>ein, wo wir den Namen des Textfeldes als Parameter übergeben:<\/p>\n
Private Sub <\/span>txtOrt_Dirty(Cancel As Integer<\/span>)\r\n     Textbox_Dirty \"txtOrt\"\r\nEnd Sub<\/span><\/pre>\n
Und es geht mit noch weniger Aufwand. Die folgende geänderte Version der Prozedur Textbox_Dirty <\/b>verlangt noch nicht einmal mehr nach einen Parameter. Stattdessen ermittelt sie die betroffene Textbox über die Funktion Screen.ActiveControl<\/b>, die immer einen Verweis auf das Steuerelement mit dem Fokus zurückliefert, und speichert dieses in der Variablen txt<\/b>. Dann referenziert sie statt Me(strTextfeld) <\/b>direkt die Variable txt<\/b>. Die Referenz Me(strTextfeld & „_Alt“) <\/b>ersetzen wir durch Me(txt.Name & „_Alt“)<\/b>:<\/p>\n
Private Sub <\/span>Textbox_Dirty()\r\n     Dim <\/span>lngSelStart As Long<\/span>, lngSelLength As Long<\/span>\r\n     Dim <\/span>txt As <\/span>TextBox\r\n     Set<\/span> txt = Screen.ActiveControl\r\n     lngSelStart = txt.SelStart\r\n     lngSelLength = txt.SelLength\r\n     With<\/span> Me(txt.Name & \"_Alt\")\r\n         .Visible = True<\/span>\r\n         .Value = txt.OldValue\r\n     End With<\/span>\r\n     txt.SelStart = lngSelStart\r\n     txt.SelLength = lngSelLength\r\nEnd Sub<\/span><\/pre>\n
Der Aufruf reduziert sich somit um die Angabe des Parameters und kann in den Bei änderung<\/b>-Ereignisprozeduren aller betroffenen Textfelder gleich aussehen:<\/p>\n
Private Sub <\/span>txtOrt_Dirty(Cancel As Integer<\/span>)\r\n     Textbox_Dirty\r\nEnd Sub<\/span><\/pre>\n
Der komplette Code für die Textfelder sieht also wie folgt aus – hinzu kommt nur die bereits oben vorgestellte Prozedur Textbox_Dirty<\/b>:<\/p>\n
Private Sub <\/span>txtFirma_Dirty(Cancel As Integer<\/span>)\r\n     Textbox_Dirty\r\nEnd Sub<\/span>\r\nPrivate Sub <\/span>txtNachname_Dirty(Cancel As Integer<\/span>)\r\n     Textbox_Dirty\r\nEnd Sub<\/span>\r\nPrivate Sub <\/span>txtOrt_Dirty(Cancel As Integer<\/span>)\r\n     Textbox_Dirty\r\nEnd Sub<\/span>\r\nPrivate Sub <\/span>txtPLZ_Dirty(Cancel As Integer<\/span>)\r\n     Textbox_Dirty\r\nEnd Sub<\/span>\r\nPrivate Sub <\/span>txtStrasse_Dirty(Cancel As Integer<\/span>)\r\n     Textbox_Dirty\r\nEnd Sub<\/span>\r\nPrivate Sub <\/span>txtVorname_Dirty(Cancel As Integer<\/span>)\r\n     Textbox_Dirty\r\nEnd Sub<\/span><\/pre>\n
Wiederherstellung des alten Zustands durch den Benutzer<\/h2>\n
Manchmal ändert der Benutzer den Wert eines Textfeldes vielleicht mehrmals, ohne sich an der Anzeige des alten Wertes zu stören, und legt dabei den alten Wert des Textfeldes wieder fest. Ist dies der Fall, soll das Textfeld zur Anzeige des alten Wertes natürlich wieder ausgeblendet werden. Dies erreichen wir durch eine weitere Ereignisprozedur, die jeweils durch das Ereignis Bei änderung <\/b>der Textfelder angelegt wird. Für das Textfeld txtFirma <\/b>sieht das etwa wie folgt aus:<\/p>\n
Private Sub <\/span>txtFirma_Change()\r\n     Textbox_Change\r\nEnd Sub<\/span><\/pre>\n
Sie sehen schon: Wir geben uns gar nicht erst damit ab, den Code für jedes Textfeld einzeln zu hinterlegen, sondern rufen direkt eine Prozedur namens Textbox_Change <\/b>auf, die wie folgt aussieht:<\/p>\n
Private Sub <\/span>Textbox_Change()\r\n     Dim <\/span>txt As <\/span>TextBox\r\n     Set<\/span> txt = Screen.ActiveControl\r\n     If <\/span>Nz(txt.Text) = Nz(Me(txt.Name & \"_Alt\")) Then<\/span>\r\n         Me(txt.Name & \"_Alt\").Visible = False<\/span>\r\n     Else<\/span>\r\n         Me(txt.Name & \"_Alt\").Visible = True<\/span>\r\n     End If<\/span>\r\nEnd Sub<\/span><\/pre>\n
Diese Prozedur referenziert wiederum über Screen.ActiveControl <\/b>das aktive Steuerelement. Damit prüft es, ob der aktuelle Text des Steuerelements aus txt <\/b>(txt.Text<\/b>) mit dem Wert des Steuerelements aus Me(txt.Name & „_Alt“) <\/b>übereinstimmt. Beide Ausdrücke versehen wir dabei mit der Funktion Nz<\/b>, um eventuell auftretende Nullwerte direkt in leere Zeichenketten umzuwandeln. Sind beide Ausdrücke gleich, was beispielsweise geschieht, wenn Sie zuerst einen Buchstaben hinzufügen und diesen gleich wieder entfernen, dann soll das Textfeld aus Me(txt.Name & „_Alt“) <\/b>durch Einstellen von Visible <\/b>auf den Wert False <\/b>gleich wieder ausgeblendet werden. Sind die beiden Werte nicht gleich, was der Fall ist, wenn der Benutzer beispielsweise weitere Zeichen hinzugefügt hat, dann stellt die Prozedur Visible <\/b>auf True <\/b>ein.<\/p>\n
Unterschied zwischen Bei Geändert und Bei änderung<\/h2>\n
Der wichtigste Unterschied der beiden Ereignisse ist, dass Bei Geändert <\/b>(txtFirma_Dirty<\/b>) nur bei der ersten änderung nach dem Anzeigen eines Datensatzes ausgelöst wird. Dementsprechend lesen wir hier den alten Wert des Textfeldes ein und schreiben ihn in das _Alt<\/b>-Textfeld. Das Ereignis Bei änderung <\/b>(txtFirma_Change<\/b>) wird bei jeder änderung des im Textfeld enthaltenen Textes ausgelöst. Damit können wir dann jederzeit vergleichen, ob sich der aktuelle Text vom Text zum Zeitpunkt der Anzeige des Datensatzes unterscheidet, und das _Alt<\/b>-Textfeld ein- oder ausblenden.<\/p>\n
Alt-Textfelder wieder ausblenden<\/h2>\n
Wenn der Benutzer die änderungen nun vor dem Speichern mit der Escape-Taste wieder rückgängig macht oder den Datensatz speichert und etwa zu einem anderen Datensatz wechselt, sollen die Textfelder, welche die alten Werte anzeigen, wieder ausgeblendet werden. Die entsprechenden Codezeilen fügen wir also zunächst für die Ereignisprozedur ein, die durch das Ereignis Beim Anzeigen <\/b>des Formulars ausgelöst wird:<\/p>\n
Private Sub <\/span>Form_Current()\r\n     Me!txtFirma_Alt.Visible = False<\/span>\r\n     Me!txtVorname_Alt.Visible = False<\/span>\r\n     Me!txtNachname_Alt.Visible = False<\/span>\r\n     Me!txtStrasse_Alt.Visible = False<\/span>\r\n     Me!txtPLZ_Alt.Visible = False<\/span>\r\n     Me!txtOrt_Alt.Visible = False<\/span>\r\nEnd Sub<\/span><\/pre>\n
Wir stellen hier einfach die Eigenschaft Visible <\/b>für alle sechs Textfelder zur Anzeige der alten Werte auf den Wert False <\/b>ein.<\/p>\n
Das ging schnell, aber wenn Sie eine ähnliche Funktion für weitere Formulare oder für Formulare mit sehr vielen Textfeldern einsetzen wollen, sollten Sie doch die Tatsache nutzen, dass wir für alle Textfelder zur Anzeige der alten Daten eine spezielle Benennungskonvention vorgenommen haben – nämlich das Anhängen der Zeichenfolge _Alt <\/b>an den Textfeldnamen, dessen alten Wert das Textfeld anzeigen soll. Also ersetzen wir die Anweisungen durch die in der folgenden Version der Prozedur Form_Current<\/b>:<\/p>\n
Private Sub <\/span>Form_Current()\r\n     Dim <\/span>ctl As <\/span>Control\r\n     For Each ctl In Me.Controls\r\n         If <\/span>ctl.ControlType = acTextBox Then<\/span>\r\n             If <\/span>Right<\/span>(ctl.Name, 4) = \"_Alt\" Then<\/span>\r\n                 ctl.Visible = False<\/span>\r\n             End If<\/span>\r\n         End If<\/span>\r\n     Next<\/span> ctl\r\nEnd Sub<\/span><\/pre>\n
Hier durchlaufen wir in einer For Each<\/b>-Schleife alle Steuerelemente des Formulars und prüfen in einer ersten If…Then<\/b>-Schleife, ob der Steuerelementtyp dem Wert acTextBox <\/b>entspricht, also ob es sich um ein Textfeld handelt. Falls ja, prüft eine weitere If…Then<\/b>-Bedingung, ob die letzten vier Buchstaben des Namens des Steuerelements _Alt <\/b>lauten.<\/p>\n
Ist auch dies der Fall, haben wir es offensichtlich mit einem der Textfelder zur Anzeige der alten Werte zu tun und können die Eigenschaft Visible <\/b>auf den Wert False <\/b>einstellen.<\/p>\n
Rücknahme von änderungen per Escape-Taste<\/h2>\n
Nun fehlt noch eine wichtige Aktion, die der Benutzer durchführen kann: Wenn er nämlich die Escape-Taste betätigt, werden die bereits durchgeführten änderungen schrittweise rückgängig gemacht. Im Beitrag Undo-Ereignis und Undo per Escape im Griff <\/b>(www.access-im-unternehmen.de\/1086<\/b>) finden Sie die Grundlagen zum Undo-Ereignis von Formularen und von gebundenen Steuerelementen. Wir entnehmen dort Folgendes:<\/p>\n