<\/p>\n
In den Beiträgen „Undo in Haupt- und Unterformular“ und „Undo in Haupt- und Unterformular mit Klasse“ haben wir gezeigt, wie Sie die Undo-Funktion etwa durch einen Abbrechen-Schaltfläche nicht nur auf das Hauptformular, sondern auch auf die änderungen im Unterformular erstrecken. Nun hat ein Leser gefragt, ob man dies auch für mehrere Unterformulare erledigen kann. Klar kann man – die angepasste Lösung stellt der vorliegende Beitrag vor.<\/b><\/p>\n
Dabei setzen wir auf der Lösung aus dem Beitrag Undo in Haupt- und Unterformular mit Klasse <\/b>(www.access-im-unternehmen.de\/912<\/b>) auf. Diese enthält im Vergleich zu dem vorherigen Beitrag eine Klasse mit der vollständigen Funktionalität für das Implementieren des Undo in Haupt- und Unterformular, die man nur noch im Ereignis Beim Laden <\/b>des Hauptformulars initialisieren und mit einigen Eigenschaften versehen muss. Der dazu anzulegende Code war sehr überschaubar gemessen an der Funktion, die er hinzufügte.<\/p>\n
Die Einschränkung dieser Klasse ist, dass man in dieser lediglich das Hauptformular und das Unterformular angeben konnte, auf die sich die Undo-Funktion auswirken sollte. Wenn man ein zweites Unterformular hinzufügen wollte, war das nicht möglich. Also schauen wir uns im vorliegenden Beitrag an, wie wir dieses Feature nachrüsten.<\/p>\n
Aber wie viele Formular dürfen es denn sein Reichen zwei aus – oder benötigt man drei oder vier Unterformulare Und macht man sich denn mit so vielen Unterformularen nicht die übersicht im Formular kaputt Der Leser, der mit seiner Anfrage an uns herangetreten ist, lieferte gleich einen Screenshot seines Formulars mit, auf dem ersichtlich wurde, dass er ein Register-Steuerelement verwendet, um die verschiedenen Unterformulare im Formular unterzubringen. So gelingt das natürlich bei Erhaltung guter übersicht.<\/p>\n
Damit war klar: Wir sollten uns nicht unbedingt einer Einschränkung hingeben und eine Lösung programmieren, die beliebig viele Unterformulare berücksichtigt.<\/p>\n
Dennoch haben wir, um uns ein wenig in den VBA-Code der anzupassenden Lösung einzuarbeiten, zunächst die bestehende Lösung auf den Einsatz mit zwei Unterformularen erweitert. Dazu haben wir lediglich im Code überall dort, wo bisher das Unterformular erwähnt wurde, den Code für ein zweites Unterformular untergebracht. Das klappte recht leicht – die Hauptarbeit war Copy and Paste und ein wenig Achtsamkeit an den richtigen Stellen.<\/p>\n
Klar: Die Anzahl der Unterformular je Formulare ist begrenzt. Dennoch wollen Sie den Code der Klasse ja nicht jedes Mal erweitern, wenn ein neues Unterformular zum Formular hinzukommt. Wir wollen dann maximal ein paar Zeilen Code im Beim Laden<\/b>-Ereignis hinzufügen, die das neu hinzugekommene Formular und dessen Datenherkunft sowie das Fremdschlüsselfeld der zugrunde liegenden Tabelle an die Klasse übergeben.<\/p>\n
Dafür ist dann zum Umwandeln des Codes ein wenig mehr Aufwand erforderlich. Aber es lohnt sich!<\/p>\n
Wenn Sie bereits andere Lösungen von uns gesehen haben, die Funktionen in Klassen auslagern und bei denen sich die Funktion auf ein oder mehrere Steuer-elemente bezieht, dann wissen Sie bereits: Es wird eine Collection geben, welche die Informationen für die in beliebiger Anzahl auftretenden Unterformulare aufnehmen soll. Dazu legen wir für jedes Unterformular eine neue Klasse an, die dann in der Collection gespeichert wird. Das heißt weiter: Wir benötigen nicht mehr nur eine Hauptklasse, sondern noch eine weitere Klasse für die untergeordneten Steuer-elemente.<\/p>\n
Bild 1 zeigt schon einmal, wie das Endergebnis aussehen soll. Zu diesem Zweck haben wir drei Tabellen namens tblHaupt<\/b>, tblUnter1 <\/b>und tblUnter2 <\/b>erstellt, von denen die letzten beiden per Fremdschlüssel die erste Tabelle referenzieren.<\/p>\n
![\"Formular](\"..\/fileadmin\/_temp_\/2017_06\/pic_1109_001.png\")
<\/p>\n
Bild 1: Formular mit zwei Unterformularen<\/span><\/b><\/p>\n Das Hauptformular ist an die Tabelle tblHaupt <\/b>gebunden, die beiden Unterformulare an die Tabellen tblUnter1 <\/b>und tblUnter2<\/b>.<\/p>\n Damit die Daten in diesen drei Formularen auch nach dem ändern von Daten im Hauptformular und in den beiden Unterformularen noch wieder hergestellt werden können, ist nur wenig Code notwendig, wenn die beiden Klassen clsUndoMultiMain <\/b>und clsUndoMultiSub <\/b>einmal zur Datenbank hinzugefügt wurden.<\/p>\n Diese sieht dann nämlich wie in Listing 1 aus. Hier deklarieren wir im allgemeinen Teil der Code behind-Klasse des Formulars die Variable objUndoMultiMain <\/b>vom Typ clsUndoMultiMain<\/b>. Diese erstellen wir dann in der Beim Laden<\/b>-Ereignisprozedur, wo wir zuerst die Datenherkunft des Hauptformulars für RecordsourceForm <\/b>angeben, dann das Primärschlüsselfeld der Datenherkunft des Hauptformulars und schließlich einen Verweis auf das Hauptformular selbst. <\/p>\n Listing 1: Code zum Einbinden der Funktion zum Undo in Haupt- und Unterformular<\/span><\/b><\/p>\n Dann folgen die neuen Elemente: Die Methode AddSubform <\/b>kann nämlich so oft aufgerufen werden, wie es nötig ist, und damit ein oder mehrere Unterformulare in die Undo<\/b>-Funktion einschließen.<\/p>\n Dazu übergeben Sie dieser Methode die folgenden drei Parameter:<\/p>\n Die grundlegende Idee ist es, die gesamte Bearbeitung des aktuellen Datensatzes des Hauptformulars und der mit diesem Datensatz verknüpften Datensätze im Unterformular in eine Transaktion einzuarbeiten. Dazu gibt es einen wichtigen Unterschied zur herkömmlichen Arbeit mit an Formulare gebundene Datenherkünften: Diese dürfen nämlich nicht wie sonst einfach etwa über die Eigenschaft Recordsource <\/b>beziehungsweise Datenherkunft <\/b>an die Formulare und Unterformulare gebunden werden. Stattdessen erstellen wir diese als zunächst unabhängiges Recordset und weisen dieses dann der Recordset<\/b>-Eigenschaft des Hauptformulars und der Unterformulare zu.<\/p>\n Die Recordsets erstellen wir im Kontext eines Database<\/b>-Objekts, das direkt dem Workspace<\/b>-Objekt der aktuellen Sitzung untergeordnet ist. Auf diese Weise können wir in den Recordsets änderungen vornehmen und diese dann über die Transaction<\/b>-Methoden BeginTrans<\/b>, CommitTrans <\/b>und Rollback <\/b>des Workspace<\/b>-Objekts nach den Wünschen des Benutzers entweder zusammen speichern oder verwerfen.<\/p>\n Die Hauptklasse clsUndoMultiMain <\/b>nimmt die wichtigsten Elemente wie das Database<\/b>– und das Workspace<\/b>-Objekt auf und enthält die Ereignisprozeduren, die für das Hauptformular angelegt werden. Die Klasse clsUndoMultiSub<\/b>, die für jedes Unterformular einmal als Objekt angelegt wird, erhält den Verweis auf das jeweilige Unterformular und implementiert die Ereignisprozeduren für das Unterformular.<\/p>\n Wichtig: Hierbei ist zu beachten, dass das Unterformular ein VBA-Klassenmodul enthält! Sie können das am einfachsten erreichen, indem Sie die Eigenschaft Enthält Modul <\/b>auf Ja <\/b>einstellen. Anderenfalls werden die Ereignisprozeduren, die in der Klasse clsUndoMultiSub <\/b>angelegt sind, nicht für das betroffene Unterformular ausgelöst. Beim Hauptformular sollte dies standardmäßig der Fall sein, da wir dort ja auch die Ereignisprozedur Form_Load <\/b>unterbringen, in der wie die Undo<\/b>-Klassen initialisieren und einstellen.<\/p>\n Die ersten beiden Einstellungen, die der Benutzer vornehmen muss, sind der Name des Primärschlüssels der Datenherkunft des Formulars sowie der Name der Datenherkunft. Diese landen in den beiden folgenden Variablen:<\/p>\n Damit diese Variablen über die Eigenschaft PKForm <\/b>gefüllt und ausgelesen werden kann, legen wir die beiden folgenden Property Let<\/b>\/Get<\/b>-Prozeduren an:<\/p>\n Für m_RecordsourceForm <\/b>benötigen wir nur eine öffentliche Eigenschaft zum Zuweisen, ausgelesen wird diese Eigenschaft von außen nicht:<\/p>\n Die Klasse clsUndoMultiMain<\/b> enthält außerdem die folgenden zwei Elemente, für welche Ereignisprozeduren implementiert werden:<\/p>\n über die folgenden beiden Property Set<\/b>-Methoden können die Schaltflächen des Formulars den Variablen zugewiesen werden.<\/p>\n Dabei stellen wir auch gleich ein, dass das Ereignis Beim Klicken <\/b>in dieser Klasse implementiert werden soll:<\/p>\n Der Verweis auf das Hauptformular soll in der Variablen m_Form <\/b>gespeichert werden, für das wir ebenfalls Ereignisprozeduren implementieren wollen können:<\/p>\n Die beiden folgenden Variablen nehmen die Verweise auf das Database<\/b>– und das Workspace<\/b>-Objekt auf:<\/p>\n Die Variable m_Form <\/b>wird über die folgende Property Set<\/b>-Methode gefüllt, die auch gleich einstellt, für welche Ereignisse im aktuellen Modul Ereignisprozeduren hinterlegt werden sollen. Außerdem werden hier die beiden Variablen m_db <\/b>und m_wrk <\/b>gefüllt.<\/p>\n Schließlich füllt sie noch das Recordset des Hauptformulars mit der in m_RecordsourceForm <\/b>angegebenen Datenherkunft (zuerst als Recordset rst <\/b>als Element des aktuelle Database<\/b>-Objekts und dann durch Zuweisen dieser Variablen an die Recordset<\/b>-Eigenschaft des Formulars):<\/p>\n Wir müssen auch von der Klasse clsUndoMultiSub <\/b>auf das in clsUndoMultiMain <\/b>enthaltene Formular zugreifen können, also legen wir auch eine Property Get<\/b>-Prozedur an:<\/p>\n Auch die Variable m_wrk <\/b>mit dem Workspace-Objekt wollen wir von den Unterklassen aus nutzen. Dazu legen wir die folgende Property Get<\/b>-Methode an:<\/p>\n Es gibt noch drei Eigenschaften, mit denen wir den aktuellen Zustand der Daten im Formular speichern müssen. Diese sollen in der Hauptklasse clsUndoMultiMain <\/b>gespeichert werden, aber auch von den Unterklassen zugreifbar sein. Daher legen wir auch diese als private Variablen an:<\/p>\n m_DirtyForm <\/b>müssen wir lesen und schreiben können:<\/p>\n Gleiches gilt für m_SavedForm<\/b>:<\/p>\n <\/p>\n m_DeletedForm <\/b>verwenden wir nur innerhalb der Klasse clsUndoMultiMain<\/b>, also brauchen wir keine Property<\/b>-Eigenschaften. Schließlich fehlt noch eine Collection<\/b>-Variable, in der wir die durch die weiter unten beschriebene AddSubform<\/b>-Methode hinzugefügten Instanzen der Klasse clsUndoMultiSub <\/b>speichern:<\/p>\n Diese instanzieren wir in dem folgenden Ereignis, das gleich beim Erstellen der Klasse clsUndoMultiMain <\/b>ausgelöst wird:<\/p>\n Damit kommen wir auch gleich zur Methode AddSubform<\/b>. Diese sieht wie folgt aus und erwartet die weiter oben beschriebenen Parameter:<\/p>\n Sie erstellt mit jedem Aufruf ein neues Objekt des Typs clsUndoMultiSub <\/b>und speichert dieses in objUndoMultiSub<\/b>. Dann stellt sie die mit den Parametern übergebenen Werte ein (die Innereien dieser Klasse schauen wir uns ebenfalls weiter unten an). Die in dieser Methode deklarierte Objektvariable objUndoMultiSub <\/b>würde mit Beenden der Methode ihre Gültigkeit verlieren, also fügen wir diese mit der Add<\/b>-Methode zur die Auflistung col <\/b>hinzu.<\/p>\n Damit die Unterformulare anzeigen, muss das Ereignis Beim Anzeigen des Hauptformulars ausgelöst werden. Warum Weil immer, wenn der Benutzer den Datensatz im Hauptformular wechselt, auch die Datensätze in den Unterformularen aktualisiert werden müssen. Sie erinnern sich Wir können nicht mit einer herkömmlichen Bindung zwischen Haupt- und Unterformular arbeiten, weil wir die Daten der Formulare jeweils erst in Recordsets auf Basis des aktuellen Workspaces schreiben und dann an die Eigenschaft Recordset <\/b>der Formulare übergeben müssen. Anders können wir die änderungen an allen Recordsets nicht innerhalb einer Transaktion erfassen und gegebenenfalls rückgängig machen.<\/p>\n Deshalb richten wir für das Ereignis Beim Anzeigen <\/b>des Recordsets im Hauptformular die Ereignisprozedur aus Listing 2 ein. Entscheidend für den Moment ist der untere Teil, wo eine If…Then<\/b>-Bedingung prüft, ob das Hauptformular gerade einen neuen oder einen bereits vorhandenen Datensatz anzeigt. Im Falle eines vorhandenen Datensatzes stellt die Prozedur eine Abfrage zusammen, welche alle Datensätze der Datenherkunft des Unterformulars ermittelt, deren Fremdschlüsselfeld dem aktuellen Primärschlüssel im Hauptformular entspricht. Das auf dieser Abfrage basierende Recordset wird dann der Eigenschaft Recordset des jeweiligen Unterformulars zugewiesen.<\/p>\n Listing 2: Code, der beim Wechseln des Datensatzes im Hauptformular ausgeführt wird.<\/span><\/b><\/p>\n Neu gegenüber der vorherigen Version, die nur ein einziges Unterformular erlaubte, eine For Each<\/b>-Schleife, welche alle Unterformulare der in der Collection col <\/b>gespeicherten Klassen durchläuft und diese mit den passenden Daten füllt.<\/p>\n Handelt es sich hingegen um einen neuen Datensatz im Hauptformular, durchläuft die Prozedur in einer alternativen For Each<\/b>-Schleife alle Unterformular-Klassen und fügt allen einen Recordset auf Basis der angegebenen Datenherkunft zu, allerdings mit einem Kriterium (1=2<\/b>), das keine Ergebnisse liefert.<\/p>\n Das ist korrekt, denn ein neuer Datensatz im Hauptformular darf natürlich noch keine Datensätze in den Unterformularen enthalten.<\/p>\n Im oberen Teil prüft die Prozedur, ob m_DeletedForm <\/b>den Wert True <\/b>enthält, was zeigt, dass der Datensatz im Hauptformular gelöst wurde. In diesem Fall wird die Transaktion beendet und die drei Variablen m_DeletedForm<\/b>, m_SavedForm <\/b>und m_DirtyForm <\/b>auf False <\/b>eingestellt – also ein unbearbeiteter Zustand angegeben.<\/p>\n Wurde der aktuelle Datensatz nicht gelöscht, prüft die Prozedur, ob m_DirtyForm <\/b>den Wert True <\/b>hat, was bedeuten würde, dass der zuvor angezeigte Datensatz bearbeitet wurde. In diesem Fall wird der Datensatz gespeichert und auch die Transaktion abgeschlossen, damit auch die änderungen in den Unterformularen gespeichert werden.<\/p>\n Auch dann werden m_DirtyForm <\/b>und m_SavedForm <\/b>auf False <\/b>eingestellt.<\/p>\n Wenn der Benutzer einen Datensatz im Hauptformular löscht, werden die beiden folgenden Prozeduren ausgelöst. Die erste stellt einfach nur ein, dass keine Rückfrage angezeigt wird:<\/p>\n Die zweite prüft, ob bereits Daten im Haupt- oder Unterformular bearbeitet wurden, wodurch die Variable m_DirtyForm <\/b>den Wert True <\/b>hätte. Dann würde die Transaktion zuvor noch zurückabgewickelt werden:<\/p>\n Wenn der Benutzer die am aktuellen Datensatz des Hauptformulars und an den Datensätzen im Unterformular vorgenommen änderungen zurücknehmen möchte, klickt er die Schaltfläche an, die für die Eigenschaft m_CancelButton <\/b>hinterlegt wurde. Diese löst das Beim Klicken<\/b>-Ereignis aus, für die wir folgende Ereignisprozedur angelegt haben:<\/p>\nUndo-Funktion implementieren<\/h2>\n
Dim <\/span>objUndomultiMain As <\/span>clsUndoMultiMain\r\nPrivate Sub <\/span>Form_Load()\r\n Set<\/span> objUndomultiMain = New<\/span> clsUndoMultiMain\r\n With<\/span> objUndomultiMain\r\n .RecordsourceForm = \"tblHaupt\"\r\n .PKForm = \"HauptID\"\r\n Set<\/span> .Form = Me\r\n .AddSubform Me!sfmUnter1.Form, \"tblUnter1\", \"HauptID\"\r\n .AddSubform Me!sfmUnter2.Form, \"tblUnter2\", \"HauptID\"\r\n Set<\/span> .OKButton = Me!cmdOK\r\n Set<\/span> .CancelButton = Me!cmdAbbrechen\r\n End With<\/span>\r\nEnd Sub<\/span><\/pre>\n\n
Grundlegende Technik<\/h2>\n
Zusammenhang zwischen den beiden Klassen<\/h2>\n
Private <\/span>m_PKForm As String<\/span>\r\nPrivate <\/span>m_RecordsourceForm As String<\/span><\/pre>\nPublic Property Let <\/span>PKForm(str As String<\/span>)\r\n m_PKForm = str\r\nEnd Property<\/span>\r\nPublic Property Get <\/span>PKForm() As String<\/span>\r\n PKForm = m_PKForm\r\nEnd Property<\/span><\/pre>\nPublic Property Let <\/span>RecordsourceForm(str As String<\/span>)\r\n m_RecordsourceForm = str\r\nEnd Property<\/span><\/pre>\nPrivate <\/span>WithEvents m_OKButton As <\/span>CommandButton\r\nPrivate <\/span>WithEvents m_CancelButton As <\/span>CommandButton<\/pre>\nPublic Property Set<\/span> <\/span>OKButton(cmd As <\/span>CommandButton)\r\n Set<\/span> m_OKButton = cmd\r\n With<\/span> m_OKButton\r\n .OnClick = \"[Event Procedure]\"\r\n End With<\/span>\r\nEnd Property<\/span>\r\nPublic Property Set<\/span> <\/span>CancelButton(cmd As <\/span>CommandButton)\r\n Set<\/span> m_CancelButton = cmd\r\n With<\/span> m_CancelButton\r\n .OnClick = \"[Event Procedure]\"\r\n End With<\/span>\r\nEnd Property<\/span><\/pre>\nAngabe des Hauptformulars<\/h2>\n
Private <\/span>WithEvents m_Form As <\/span>Form<\/pre>\nPrivate <\/span>m_db As <\/span>DAO.Database\r\nPrivate <\/span>m_wrk As <\/span>DAO.Workspace<\/pre>\nPublic Property Set<\/span> <\/span>Form(frm As <\/span>Form)\r\n Dim <\/span>rst As <\/span>DAO.Recordset\r\n Set<\/span> m_Form = frm\r\n With<\/span> m_Form\r\n .AfterUpdate = \"[Event Procedure]\"\r\n .BeforeDelConfirm = \"[Event Procedure]\"\r\n .OnCurrent = \"[Event Procedure]\"\r\n .OnDelete = \"[Event Procedure]\"\r\n .OnDirty = \"[Event Procedure]\"\r\n .OnError = \"[Event Procedure]\"\r\n .OnOpen = \"[Event Procedure]\"\r\n .OnUnload = \"[Event Procedure]\"\r\n .OnUndo = \"[Event Procedure]\"\r\n End With<\/span>\r\n Set<\/span> m_db = DBEngine(0)(0)\r\n Set<\/span> m_wrk = DBEngine.Workspaces(0)\r\n Set<\/span> rst = m_db.OpenRecordset(m_RecordsourceForm, _\r\n dbOpenDynaset)\r\n Set<\/span> m_Form.Recordset = rst\r\nEnd Property<\/span><\/pre>\nPublic Property Get <\/span>Form() As <\/span>Form\r\n Set<\/span> Form = m_Form\r\nEnd Property<\/span><\/pre>\nPublic Property Get <\/span>wrk() As <\/span>DAO.Workspace\r\n Set<\/span> wrk = m_wrk\r\nEnd Property<\/span><\/pre>\nPrivate <\/span>m_DirtyForm As Boolean<\/span>\r\nPrivate <\/span>m_SavedForm As Boolean<\/span>\r\nPrivate <\/span>m_DeletedForm As Boolean<\/span><\/pre>\nPublic Property Get <\/span>DirtyForm() As Boolean<\/span>\r\n DirtyForm = m_DirtyForm\r\nEnd Property<\/span>\r\nPublic Property Let <\/span>DirtyForm(bol As Boolean<\/span>)\r\n m_DirtyForm = bol\r\nEnd Property<\/span><\/pre>\nPublic Property Get <\/span>SavedForm() As Boolean<\/span>\r\n SavedForm = m_SavedForm\r\nEnd Property<\/span>\r\nPublic Property Let <\/span>SavedForm(bol As Boolean<\/span>)\r\n m_SavedForm = bol\r\nEnd Property<\/span><\/pre>\nPrivate <\/span>col As <\/span>Collection<\/pre>\nPrivate Sub <\/span>Class_Initialize()\r\n Set<\/span> col = New<\/span> Collection\r\nEnd Sub<\/span><\/pre>\nUnterklassen für Unterformular hinzufügen<\/h2>\n
Public Sub <\/span>AddSubform(frm As <\/span>Form, _\r\n strRecordsourceSubform As String<\/span>, _\r\n strFKSubform As String<\/span>)\r\n Dim <\/span>objUndoMultiSub As <\/span>clsUndoMultiSub\r\n Set<\/span> objUndoMultiSub = New<\/span> clsUndoMultiSub\r\n With<\/span> objUndoMultiSub\r\n Set<\/span> .Main = Me\r\n Set<\/span> .Subform = frm\r\n .RecordsourceSubform = strRecordsourceSubform\r\n .FKSubform = strFKSubform\r\n End With<\/span>\r\n col.Add objUndoMultiSub\r\nEnd Sub<\/span><\/pre>\nDaten im Unterformular anzeigen<\/h2>\n
Private Sub <\/span>m_Form_Current()\r\n Dim <\/span>objUndoMultiSub As <\/span>clsUndoMultiSub\r\n If <\/span>m_DeletedForm = True<\/span> Then<\/span>\r\n m_wrk.CommitTrans\r\n m_SavedForm = False<\/span>\r\n m_DirtyForm = False<\/span>\r\n m_DeletedForm = False<\/span>\r\n Else<\/span>\r\n If <\/span>m_DirtyForm = True<\/span> Then<\/span>\r\n DoCmd.RunCommand acCmdSaveRecord\r\n m_wrk.CommitTrans\r\n m_SavedForm = False<\/span>\r\n m_DirtyForm = False<\/span>\r\n End If<\/span>\r\n End If<\/span>\r\n If <\/span>Not<\/span> m_Form.NewRecord Then<\/span>\r\n For Each objUndoMultiSub In col\r\n Set<\/span> objUndoMultiSub.rst = m_db.OpenRecordset(\"SELECT * FROM \" & objUndoMultiSub.RecordsourceSubform _\r\n & \" WHERE \" & objUndoMultiSub.FKSubform & \" = \" & Nz(m_Form.Recordset.Fields(m_PKForm), 0), dbOpenDynaset)\r\n Next<\/span> objUndoMultiSub\r\n Else<\/span>\r\n For Each objUndoMultiSub In col\r\n Set<\/span> objUndoMultiSub.rst = m_db.OpenRecordset(\"SELECT * FROM \" & objUndoMultiSub.RecordsourceSubform _\r\n & \" WHERE 1=2\", dbOpenDynaset)\r\n Next<\/span> objUndoMultiSub\r\n End If<\/span>\r\nEnd Sub<\/span><\/pre>\nDatensatz löschen<\/h2>\n
Private Sub <\/span>m_Form_BeforeDelConfirm(Cancel As Integer<\/span>, _\r\n Response As Integer<\/span>)\r\n Response = acDataErrContinue\r\nEnd Sub<\/span><\/pre>\nPrivate Sub <\/span>m_Form_Delete(Cancel As Integer<\/span>)\r\n If <\/span>m_DirtyForm Then<\/span>\r\n m_wrk.Rollback\r\n End If<\/span>\r\n m_DeletedForm = True<\/span>\r\nEnd Sub<\/span><\/pre>\nUndo auslösen<\/h2>\n
Private Sub <\/span>m_CancelButton_Click()\r\n If <\/span>m_DirtyForm = True<\/span> Then<\/span>\r\n If <\/span>Not<\/span> m_SavedForm Then<\/span>\r\n If <\/span>m_Form.Dirty Then<\/span>\r\n m_Form.Undo\r\n Else<\/span>\r\n RunCommand acCmdSaveRecord\r\n End If<\/span>\r\n End If<\/span>\r\n m_wrk.Rollback\r\n m_DirtyForm = False<\/span>\r\n End If<\/span>\r\nEnd Sub<\/span><\/pre>\n