<\/p>\n
Seit Access 2007 bietet Access für Memofelder die Möglichkeit, die verschiedenen Versionen zu speichern. Wie aber können wir solche Änderungen wieder rückgängig machen, ohne dass der Benutzer die eingebauten Funktionen dafür nutzen muss oder gar ein extra Formular, dass die bisher gespeicherten Versionen anzeigt Sondern einfach etwa mit zwei Schaltflächen, mit denen er zwischen den vorhandenen History-Einträgen hin- und herblättern kann Wie das gelingt, zeigen wir in diesem Beitrag.<\/b><\/p>\nVorbereitungen<\/h2>\n
Wenn Sie ein Memofeld verwenden wollen, um verschiedene Versionsstände des enthaltenen Textes speichern zu können, brauchen Sie prinzipiell nur eine einzige Eigenschaft des Memofeldes zu ändern (in aktuelleren Versionen von Access heißt der Datentyp für längere Texte übrigens nicht mehr Memofeld<\/b>, sondern Langer Text<\/b>).<\/p>\n
Diese Eigenschaft stellen Sie im Entwurf der Tabelle mit dem Memofeld ein, indem Sie dieses markieren und dann für die Eigenschaft Nur Anfügen <\/b>den Wert Ja <\/b>festlegen – wie für das Feld Inhalt <\/b>in Bild 1.<\/p>\n
![\"Memofeld](\"..\/fileadmin\/_temp_\/2019_05\/pic_1205_001.png\")
<\/p>\n
Bild 1: Memofeld mit History-Funktion<\/span><\/b><\/p>\n Wenn Sie nun in die Datenblattansicht wechseln, können Sie wie gewohnt Texte in das Memofeld eingeben – etwa so wie in Bild 2.<\/p>\n Bild 2: Eingeben eines Textes<\/span><\/b><\/p>\n Speichern Sie den Text nun, indem Sie das Feld verlassen, und fügen Sie dann weiteren Text hinzu – siehe Bild 3.<\/p>\n Bild 3: Eingeben eines weiteren Textes<\/span><\/b><\/p>\n Die Datenblattansicht zeigt nun die neueste Version des Inhalts des Memofelds an.<\/p>\n Wie greifen wir nun auf die Historie zu Diese erhalten wir, indem wir aus dem Kontextmenü des Feldes in der Datenblattansicht den Eintrag Spaltenverlauf anzeigen… <\/b>aufrufen (siehe Bild 4).<\/p>\n Bild 4: Aufruf der Historie<\/span><\/b><\/p>\n Danach erscheint der Dialog Verlauf für Inhalt<\/b>, der in einem Textfeld alle Änderungsdaten samt des zu diesem Zeitpunkt vorliegenden Inhalts anzeigt (siehe Bild 5).<\/p>\n Bild 5: Anzeige der Historie<\/span><\/b><\/p>\n Damit erhalten wir allerdings noch nicht die Gelegenheit, auf einen bestimmten Versionsstand zuzugreifen und diesen wiederherzustellen.<\/p>\n Wenn wir versuchen, die Versionsstände per DLookup <\/b>abzufragen, erhalten wir jeweils nur die aktuelle Version des Memofeld-Inhalts:<\/p>\n Es gibt jedoch eine neue Methode des Application<\/b>-Objekts namens ColumnHistory<\/b>, welche auch den im Textfeld des Dialogs Verlauf für Inhalt <\/b>angezeigten Text liefert. Diese erwartet drei Parameter:<\/p>\n Ein Aufruf könnte etwa wie folgt aussehen:<\/p>\n Das Hinzufügen eines neuen Versionsstandes erfolgt erst, wenn der Benutzer den Datensatz speichert. Das Verlassen des Feldes und somit der Fokusverlust reicht nicht aus.<\/p>\n Damit können wir nun noch nicht auf die einzelnen Versionsstände des Textes des Memofelds zugreifen, was aber nötig ist, um komfortabel zwischen den verfügbaren Versionsständen hin- und herzuschalten.<\/p>\n Um dies zu realisieren, erstellen wir zunächst ein neues Formular, das über die Eigenschaft Datensatzquelle<\/b> an die Tabelle tblMemofeld <\/b>gebunden ist. Wir ziehen alle Felder aus der Feldliste in den Entwurf des Formulars.<\/p>\n Dann fügen wir drei Steuer-elemente zum Formular hinzu, die wir wie in Bild 6 neben dem Textfeld für das Memofeld platzieren. Die beiden Schaltflächen heißen cmdVorheriger <\/b>und cmdNaechster<\/b>. Das Textfeld soll die Bezeichnung txtVersion <\/b>erhalten. Außerdem stellen wir die Eigenschaft Aktiviert <\/b>auf Nein <\/b>und Gesperrt <\/b>auf Ja <\/b>ein – so wird der Inhalt weiterhin angezeigt, kann aber vom Benutzer nicht geändert werden.<\/p>\n Bild 6: Steuer-elemente zum Navigieren in den Versionen<\/span><\/b><\/p>\n Für die nachfolgend hinzuzufügenden Prozeduren benötigen wir zwei allgemein deklarierte Variablen, die Sie wie folgt zum Klassenmodul des Formulars frmMemofelder <\/b>hinzufügen:<\/p>\n Die Variable colVersions <\/b>soll eine Collection aufnehmen, die wir mit den Texten der verschiedenen Versionen des Memofeldes füllen.<\/p>\n Dies erledigen wir zu verschiedenen Gelegenheiten. Wichtig ist zunächst, dass wir die Prozedur erstellen, mit der die verschiedenen Versionsstände des Inhalts des Memofeldes für den aktuellen Datensatz ermittelt und in das Collection<\/b>-Objekt eingetragen werden können. Diese Prozedur finden Sie in Listing 1. Sie deklariert zunächst einige Variablen und initialisiert dann die Objektvariable colVersions <\/b>des Typs Collection<\/b>.<\/p>\n <\/p>\n Listing 1: Prozedur zum Aktualisieren der Version<\/span><\/b><\/p>\n Die Prozedur prüft mit Not IsNull(Me!ID) <\/b>zuerst, ob das Primärschlüsselfeld einen Wert ungleich Null <\/b>enthält und somit, ob das Formular einen gültigen Datensatz anzeigt. Falls nicht, wird lediglich der Wert der Variablen lngVersion <\/b>auf den Wert 0 <\/b>eingestellt. Das ist beispielsweise der Fall, wenn das Formular einen neuen, leeren Datentsatz anzeigt.<\/p>\n Liegt jedoch bereits ein Datensatz vor, lesen wir den kompletten Inhalt des Memofeldes in die Variable strVersions <\/b>ein. Dazu nutzen wir die Methode ColumnHistory<\/b>, die wir bereits weiter oben vorgestellt haben.<\/p>\n Die folgende Anweisung ermittelt die Position des ersten Auftretens der Zeichenkette [Version: <\/b>und speichert den Zahlenwert in der Variablen lngPosStart<\/b>.<\/p>\n Hat lngPosStart <\/b>danach einen Wert ungleich 0 <\/b>und entspricht es nicht der Länge der gesamten in strVersions <\/b>gespeicherten Zeichenkette plus drei (Erläuterung dazu weiter unten), folgen weitere Schritte. So ermittelt die Prozedur für die Variable lngPosEnde <\/b>die Position der schließenden eckigen Klammer. Unmittelbar danach wird wieder die Position des nächsten Vorkommens von [Version: <\/b>in die Variable lngPosStart <\/b>eingetragen.<\/p>\n Hat lngPosStart <\/b>an dieser Stelle den Wert 0<\/b>, was bedeutet, dass keine weiteren Vorkommen mehr gefunden werden konnten, stellen wir den Wert von lngPosStart <\/b>auf den Wert der Länge von strVersion <\/b>plus drei ein.<\/p>\n Nun wissen wir, an welcher Stelle sich der eigentliche Text der aktuellen Version des Memofeldes befindet. Diesen Text lesen wir dann mit der Mid<\/b>-Funktion mit den entsprechenden Zahlenangaben in die Variable strVersion <\/b>ein und fügen den Inhalt mit der Add<\/b>-Methode zur Collection<\/b>-Variablen colVersions <\/b>hinzu.<\/p>\n Dies wiederholen wir in der Do While<\/b>-Schleife solange, bis entweder lngPosStart <\/b>den Wert 0<\/b> aufweist, was nur beim ersten Durchlauf der Schleife passieren kann, oder bis lngPosStart <\/b>der Länge des Textes aus strVersion <\/b>plus drei entspricht – diese Abbruchbedingung wird innerhalb der Schleife hergestellt, wenn kein weiteres Vorkommen von [Version: <\/b>mehr gefunden werden kann.<\/p>\n Nach dem Durchlaufen der Schleife stellt die Prozedur den Wert der Variablen lngVersion <\/b>auf die Anzahl der Einträge der Collection minus eins ein. Lautet dieser Wert dann -1<\/b>, weil die Collection keine Einträge enthält, weist die Prozedur lngVersion <\/b>den Wert 0 <\/b>zu. Schließlich ruft die Prozedur noch eine weitere Prozedur namens SchaltflaechenAktivieren <\/b>auf.<\/p>\n Die Prozedur SchaltflaechenAktivieren <\/b>stellt die Eigenschaft Enabled <\/b>der Schaltfläche cmdVorheriger <\/b>auf den Wert True <\/b>ein, wenn lngVersion <\/b>nicht den Wert 0 <\/b>enthält – die Schaltfläche wird also nur deaktiviert, wenn nicht gerade die erste Version angezeigt wird.<\/p>\n Wenn die Collection leer ist und die Eigenschaft Count <\/b>somit den Wert 0 <\/b>zurückliefert, stellen wir die Variable lngVersionCount <\/b>auf 1 <\/b>ein, anderenfalls auf den jeweiligen Wert von colVersions.Count<\/b>. Danach aktivieren oder deaktivieren wir die Schaltfläche cmdNaechster <\/b>in Abhängigkeit davon, ob aktuell der Inhalt der letzten Version der Collection angezeigt wird. Das Textfeld txtVersion <\/b>soll schließlich den Index der aktuellen Version anzeigen. Wenn es vier Versionen gibt und der Datensatz wird gerade geöffnet, soll hier etwa 4\/4 <\/b>stehen und die Schaltfläche cmdNaechster <\/b>soll deaktiviert sein.<\/p>\n Klickt der Benutzer dann auf die Schaltfläche cmdVorheriger<\/b>, soll die vorherige Version angezeigt werden, das Textfeld txtVersion <\/b>zeigt 3\/4 <\/b>an und die Schaltfläche cmdNaechster <\/b>wird aktiviert.<\/p>\n Das alles nützt uns gar nichts, wenn wir die Prozedur VersionAktualisieren<\/b> nicht aufrufen. Wann soll das geschehen<\/p>\n Die entsprechenden Ereignisprozeduren sehen wie folgt aus:<\/p>\n Außerdem benötigen wir noch die beiden Prozeduren, die durch die Schaltflächen cmdVorheriger <\/b>und cmdNaechster <\/b>ausgelöst werden. Die Prozedur cmdVorheriger_Click <\/b>vermindert lngVersion <\/b>um eins und schreibt den Inhalt der Collection colVersions <\/b>für den entsprechenden Index in das Textfeld Inhalt<\/b>. Danach ruft es die Prozedur SchaltflaechenAktivieren <\/b>auf:<\/p>\n Die Prozedur cmdNaechster_Click <\/b>erledigt das in der anderen Richtung, sie erhöht also lngVersion <\/b>um eins:<\/p>\n Damit erhalten Sie ein Formular in der Formularansicht wie in Bild 7. Hier haben wir einen neuen Datensatz angelegt und einen Beispieltext in das Memo-Textfeld geschrieben. Dass der Datensatz noch nicht gespeichert ist, erkennen Sie am Bearbeiten<\/b>-Symbol im Datensatzmarkierer-Bereich.<\/p>\n Bild 7: Eingabe des ersten Textes<\/span><\/b><\/p>\n Wenn Sie den Datensatz nun etwa durch einen Klick auf den Datensatzmarkierer speichern, geschieht nichts weiter – außer, dass das Bearbeiten-Symbol verschwindet. Nun geben wir weiteren Text in das Memo-Textfeld ein und ändern so seinen Inhalt. Dies ändert zunächst nichts an der Anzeige unserer Steuer-elemente zum Verwalten der Historie des Memofeldes – lediglich das Bearbeiten-Symbol erscheint wieder im Datensatzmarkierer<\/b>-Bereich. Wenn wir den Datensatzmarkierer nun erneut anklicken, werden die Steuer-elemente aktualisiert: Das Textfeld txtVersion <\/b>zeigt nun 2\/2 <\/b>statt 1\/1 <\/b>an und die Schaltfläche cmdVorheriger <\/b>wird aktiviert (siehe Bild 8).<\/p>\n Bild 8: Eingabe des zweiten Textes<\/span><\/b><\/p>\n Wenn Sie nun auf die Schaltfläche cmdVorheriger <\/b>klicken, zeigt das Formular im Textfeld txtVersion <\/b>den Ausdruck 1\/2 <\/b>an. Die Schaltfläche cmdVorheriger <\/b>wird deaktiviert, weil der erste Eintrag der Historie erreicht wurde und cmdNaechster <\/b>wird aktiviert. Außerdem zeigt das Memo-Textfeld den vorherigen Versionsstand an.<\/p>\n Gleichzeitig erscheint auch wieder das Bearbeiten-Symbol im Datensatzmarkierer-Bereich (siehe Bild 9). Das bedeutett, dass wenn Sie den Datensatz nun speichern, eine dritte Version des Textes des Memofelds angelegt wird, die wieder dem Inhalt der ersten Version entspricht. Es wird also die jeweils beim Speichern des Datensatzes vorhandene Version als neue Version in die Historie des Memofeldes übernommen. Wenn Sie sich darüber bewusst sind, steht der Nutzung der hier vorgestellten Lösung nichts mehr im Weg.<\/p>\n Bild 9: Wechseln zur ersten Version<\/span><\/b><\/p>\n Ein Zurücksetzen der gespeicherten Versionen ist nicht vorgesehen. Das heißt, es ist nur mit großem Aufwand möglich. Die Möglichkeiten lauten:<\/p>\n![\"Eingeben](\"..\/fileadmin\/_temp_\/2019_05\/pic_1205_002.png\")
<\/p>\n![\"Eingeben](\"..\/fileadmin\/_temp_\/2019_05\/pic_1205_003.png\")
<\/p>\n![\"Aufruf](\"..\/fileadmin\/_temp_\/2019_05\/pic_1205_004.png\")
<\/p>\n![\"Anzeige](\"..\/fileadmin\/_temp_\/2019_05\/pic_1205_005.png\")
<\/p>\nVersionsstände per VBA abfragen<\/h2>\n
Debug.Print<\/span> Dlookup(\"Inhalt\", \"tblMemofeld\")\r\nBeispieltext. Noch mehr Beispieltext.<\/pre>\n\n
Application.ColumnHistory(\"tblMemofeld\", \"Inhalt\", \"ID = 1\")\r\n[Version: 28.08.2019 11:34:20 ] Beispieltext.\r\n[Version: 28.08.2019 11:34:48 ] Beispieltext. Noch mehr Beispieltext.<\/pre>\n
Wann wird der Versionsstand gespeichert<\/h2>\n
Auf einzelne Einträge zugreifen<\/h2>\n
![\"Steuer-elemente](\"..\/fileadmin\/_temp_\/2019_05\/pic_1205_006.png\")
<\/p>\nDDim colVersions As <\/span>Collection\r\nDim <\/span>lngVersion As Long<\/span><\/pre>\nVersionsstände ermitteln und in Collection eintragen<\/h2>\n
Private Sub <\/span>VersionAktualisieren()\r\n Dim <\/span>strVersions As String<\/span>\r\n Dim <\/span>lngPosStart As Long<\/span>\r\n Dim <\/span>lngPosEnde As Long<\/span>\r\n Dim <\/span>strVersion As String<\/span>\r\n Set<\/span> colVersions = New<\/span> Collection\r\n If <\/span>Not<\/span> IsNull(Me!ID) Then<\/span>\r\n strVersions = Application.ColumnHistory(\"tblMemofeld\", \"Inhalt\", \"ID = \" & Me!ID)\r\n lngPosStart = InStr<\/span>(1, strVersions, \"[Version: \")\r\n Do While<\/span> Not<\/span> lngPosStart = 0 And Not<\/span> lngPosStart = Len<\/span>(strVersions) + 3\r\n lngPosEnde = InStr<\/span>(lngPosStart, strVersions, \" ] \")\r\n lngPosStart = InStr<\/span>(lngPosEnde, strVersions, \"[Version: \")\r\n If <\/span>lngPosStart = 0 Then<\/span>\r\n lngPosStart = Len<\/span>(strVersions) + 3\r\n End If<\/span>\r\n strVersion = Mid<\/span>(strVersions, lngPosEnde + 3, lngPosStart - lngPosEnde - 5)\r\n colVersions.Add (strVersion)\r\n Loop<\/span>\r\n lngVersion = colVersions.Count - 1\r\n If <\/span>lngVersion = -1 Then<\/span>\r\n lngVersion = 0\r\n End If<\/span>\r\n Else<\/span>\r\n lngVersion = 0\r\n End If<\/span>\r\n SchaltflaechenAktivieren\r\nEnd Sub<\/span><\/pre>\nSchaltflächen aktivieren und deaktivieren<\/h2>\n
Private Sub <\/span>SchaltflaechenAktivieren()\r\n Dim <\/span>lngVersionCount As Long<\/span>\r\n Me!cmdVorheriger.Enabled = Not<\/span> lngVersion = 0\r\n If <\/span>colVersions.Count = 0 Then<\/span>\r\n lngVersionCount = 1\r\n Else<\/span>\r\n lngVersionCount = colVersions.Count\r\n End If<\/span>\r\n Me!cmdNaechster.Enabled = Not<\/span> lngVersion = lngVersionCount - 1\r\n Me!txtVersion = lngVersion + 1 & \"\/\" & lngVersionCount\r\nEnd Sub<\/span><\/pre>\n\n
Private Sub <\/span>Form_AfterUpdate()\r\n VersionAktualisieren\r\nEnd Sub<\/span>\r\nPrivate Sub <\/span>Form_Current()\r\n VersionAktualisieren\r\nEnd Sub<\/span>\r\nPrivate Sub <\/span>Form_Undo(Cancel As Integer<\/span>)\r\n VersionAktualisieren\r\nEnd Sub<\/span> <\/pre>\nPrivate Sub <\/span>cmdVorheriger_Click()\r\n lngVersion = lngVersion - 1\r\n Me!Inhalt = colVersions(lngVersion + 1)\r\n SchaltflaechenAktivieren\r\nEnd Sub<\/span><\/pre>\nPrivate Sub <\/span>cmdNaechster_Click()\r\n lngVersion = lngVersion + 1\r\n Me!Inhalt = colVersions(lngVersion + 1)\r\n SchaltflaechenAktivieren\r\nEnd Sub<\/span><\/pre>\nVerhalten der Lösung<\/h2>\n
![\"Eingabe](\"..\/fileadmin\/_temp_\/2019_05\/pic_1205_007.png\")
<\/p>\n![\"Eingabe](\"..\/fileadmin\/_temp_\/2019_05\/pic_1205_008.png\")
<\/p>\nVorsicht beim Versionswechsel<\/h2>\n
![\"Wechseln](\"..\/fileadmin\/_temp_\/2019_05\/pic_1205_009.png\")
<\/p>\nZurücksetzen der Versionshistorie<\/h2>\n