<\/p>\n
Webbrowser kennen diese Funktion dank Add-Ons schon länger: Wenn Sie dort Daten in ein Formular eintragen, können Sie diese speichern und bei der nächsten Verwendung des Formulars per Mausklick erneut einfügen. Warum gibt es das unter Access eigentlich noch nicht Wie auch immer: Dieser Beitrag zeigt, wie Sie die Inhalte eines Access-Formulars zwischenspeichern und bei Bedarf wieder abrufen. Das hilft sowohl dem Entwickler als auch dem Benutzer, denn sowohl bei der Entwicklung als auch bei der Anwendung der Datenbank kann dieses Feature sehr nützlich sein – wenn auch mit leicht unterschiedlichem Ansatz.<\/b><\/p>\n
Wir wollen die Technik zum Speichern und Wiederherstellen eines Formularinhalts von zwei Seiten betrachten: Aus Entwicklersicht und aus Benutzersicht. Der Entwickler benötigt das Feature hauptsächlich, um beim Testen eines Formulars nicht die gleichen Daten immer wieder neu einzugeben, sondern diese gegebenenfalls per Mausklick zu speichern und wiederherzustellen. Für den Entwickler soll diese Funktion eher flexibel und für alle Formulare anwendbar sein – am besten also in Form eines Add-Ins, das die Inhalte mehrerer Formulare verwalten kann.<\/p>\n
Für den Benutzer ist eine eingebaute Funktion sinnvoll, welche zum einen eine Schaltfläche zum Speichern der aktuellen Eingabe bietet, zum anderen eine Auswahlmöglichkeit für die bisher gespeicherten Daten.<\/p>\n
Formularinhalte speichern für Benutzer<\/b><\/p>\n
In diesem Beitrag schauen wir uns die Variante für Benutzer an. Dazu erstellen wir zunächst ein einfaches Formular, das die Daten der Tabelle tblArtikel <\/b>in der Formularansicht anzeigt. Diesem fügen wir ein Kombinationsfeld namens cboVorlageAuswaehlen <\/b>hinzu sowie eine Schaltlfäche mit der Beschriftung Speichern<\/b> und dem Namen cboVorlageSpeichern<\/b>. Im Entwurf sieht das Formular nun wie in Bild 1 aus.<\/p>\n
![\"Das](\"..\/fileadmin\/_temp_\/2014_06\/pic_958_001.png\")
<\/p>\n
Bild 1: Das Beispielformular in der Entwurfsansicht<\/span><\/b><\/p>\n Bevor wir uns nun an die Programmierung machen können, müssen wir uns ein paar Gedanken um die Speicherung selbst machen. Die erste Frage dabei lautet: Welche Inhalte sollen überhaupt gespeichert werden Und die zweite: Wohin und wie speichern wir diese Inhalte<\/p>\n Die erste Frage ist eigentlich einfach zu beantworten: Natürlich alle Daten, die der Benutzer in das Formular eingegeben hat! Nur müssen wir noch herausfinden, in welchen Steuerelementen sich diese Daten befinden. Aber wie erkennen wir, welche Steuerelemente die Daten enthalten, die in der zugrunde liegenden Datenherkunft gespeichert werden<\/p>\n Und: Gibt es überhaupt immer eine Datenherkunft Kann es nicht sein, dass ein Formular zur Eingabe von Daten dient, die noch nicht einmal in der Datenbank gespeichert werden Dies könnte ja geschehen, wenn Sie etwa die Daten für eine Banküberweisung in ein Formular eingeben und die überweisung anstoßen. Die Daten müssen nicht zwangsläufig gespeichert werden, denn wir können diese später nach erfolgter überweisung vom Bankserver einlesen.<\/p>\n Allein die Bindung eines Steuerelements ein Feld der Datenherkunft liefert also kein Indiz dafür, dass der Inhalt des Steuerelements gespeichert und wiederhergestellt werden soll.<\/p>\n Also gestalten wir die Funktion so flexibel, dass wir sowohl einfach den Inhalt aller gebundenen Steuerelemente speichern können als auch speziell zum Speichern markierte Steuerelemente.<\/p>\n Tabelle zum Speichern der Daten<\/b><\/p>\n Die Tabelle zum Speichern der Inhalte der Steuerelemente soll ebenso flexibel sein. Wir möchten diese also nicht auf eine einzige Datenherkunft auslegen und somit nicht etwa die Artikeltabelle abbilden, sondern beliebig viele Felder für unterschiedliche Vorlagen in der Tabelle speichern.<\/p>\n Damit wir verschiedene Vorlagen für das gleiche Formular speichern können, benötigen wir ein Feld, das den Namen der Vorlage aufnimmt. Wenn wir die Vorlagen-Funktion für mehrere Formulare in der gleichen Datenbank verwenden möchten, müssen wir außerdem noch ein Feld vorsehen, das angibt, zu welchem Formular die Vorlage gehört.<\/p>\n Schließlich benötigen wir ein Feld für den Steuerelementnamen und eines für den Inhalt des Steuerelements. Welchen Datentyp soll das Feld zum Speichern der Inhalte haben Da wir einfach nur die in den Steuerelementen enthaltenen Werte speichern wollen, die ja in verschiedenen Datentypen auftreten können, verwenden wir den Datentyp Text<\/b>. Diesem können wir sowohl Texte also auch Zahlen, Datumsangaben oder Boolean<\/b>-Werte zuweisen (0<\/b>\/-1<\/b>).<\/p>\n Die Tabelle tblVorlagen<\/b> sieht im Entwurf schließlich wie in Bild 2 aus. Dort erkennen Sie auch, dass es einen aus den drei Feldern Formularname<\/b>, Vorlage <\/b>und Steuerelementname <\/b>zusammengesetzten, eindeutigen Index gibt.<\/p>\n Bild 2: Entwurf der Tabelle tblVorlagen<\/span><\/b><\/p>\n Speichern des Formularinhalts<\/b><\/p>\n Nun benötigen wir eine Prozedur, die durch das Ereignis Beim Klicken <\/b>der Schaltfläche cmdVorlageSpeichern <\/b>ausgelöst wird. Zuvor müssen wir noch festlegen, welche Felder gespeichert werden sollen. Wir wollen zwei Arten ermöglichen:<\/p>\n Die erste Variante ist für gebundene Formulare interessant, die zweite für gebundene und ungebundene Formulare. Welche Methode zum Einsatz kommt, legen wir durch eine Boolean<\/b>-Variable fest, die beim Laden des Formulars auf den entsprechenden Wert eingestellt wird.<\/p>\n Werfen wir nun einen Blick auf die Schaltfläche cmdVorlageSpeichern<\/b>. Diese löst beim Anklicken die Prozedur aus Listing 1 (Teil I) aus. Die Prozedur liest zunächst den Namen des aktuellen Formulars aus der Eigenschaft Name <\/b>in die Variable strFormular <\/b>ein. Dann prüft sie, ob aktuell im Kombinationsfeld cboVorlageAuswaehlen <\/b>ein Eintrag ausgewählt ist. Falls ja, geht sie davon aus, dass die aktuellen Inhalte des Formulars unter dem Namen der ausgewählten Vorlage gespeichert werden sollen. Das bedeutet natürlich, dass die vorhandenen Daten überschrieben werden. Der Name der aktuell ausgewählten Vorlage landet dann zunächst in der Variablen strVorlage<\/b>. Ist das Kombinationsfeld leer, trägt die Prozedur den Platzhalter [Neue Vorlage] <\/b>in die Variable strVorlage <\/b>ein.<\/p>\n Listing 1: Speichern des aktuellen Formularinhalts als Vorlage, Teil I<\/span><\/b><\/p>\n Dieser Wert wird nun in einer InputBox <\/b>angezeigt, die neben dem Text Geben Sie eine Bezeichnung für die Vorlage ein. <\/b>den in strVorlage <\/b>gespeicherten Wert als Standardwert verwendet (s. Bild 3). Anschließend löscht die Prozedur mit einer per Execute<\/b>-Methode ausgeführten DELETE<\/b>-Anweisung alle Datensätze aus der Tabelle tblVorlagen<\/b>, deren Feld Vorlage <\/b>den Wert aus strVorlage <\/b>und deren Feld Formularname <\/b>den Wert aus strFormular <\/b>enthält.<\/p>\n Bild 3: Abfrage des Namens für die neue Vorlage<\/span><\/b><\/p>\n Danach öffnet die Prozedur ein Recordset auf Basis der Tabelle tblVorlagen <\/b>und speichert den Verweis darauf in der Variablen rst<\/b>. In einer For Each<\/b>-Schleife durchläuft die Prozedur dann alle Steu-erelemente des Formulars (Me.Controls<\/b>) und speichert das aktuelle Steuerelement in der Variablen ctl<\/b>.<\/p>\n Die folgenden Anweisungen ermitteln, ob der Inhalt des Steuerelements aus ctl <\/b>gespeichert werden kann und soll. Zunächst geht die Prozedur vom Gegenteil aus und stellt die Variable bolFeldSpeichern<\/b>, die letztlich darüber entscheidet, auf den Wert False <\/b>ein.<\/p>\n Dann prüft die Prozedur den Wert der Variablen bolGebundeneFelder<\/b>. Diese wird im Kopf des Klassenmoduls deklariert:<\/p>\n Den Wert dieser Variablen legen wir in der Ereignisprozedur Beim öffnen <\/b>des Formulars fest – dazu später mehr. Hat die Variable den Wert True<\/b>, sollen die Werte aller gebundenen Felder des Formulars in der Tabelle tblVorlagen <\/b>gespeichert werden, sonst nur diejenigen Felder, deren Tag<\/b>-Eigenschaft (im Eigenschaftsfenster unter Marke <\/b>zu finden) den Wert AlsVorlageSpeichern <\/b>enthält. Die Prozedur ermittelt den Wert der Variablen bolGebundeneFelder <\/b>in einer Select Case<\/b>-Bedingung und schlägt dort den entsprechenden Weg ein.<\/p>\n Im Fall der gebundenen Felder deaktiviert die Prozedur zunächst die Fehlerbehandlung und versucht dann, den Wert der Eigenschaft ControlSource <\/b>des Steuerelements in die Variable strTest <\/b>einzulesen. Dies führt zu einem Fehler, wenn das Steuerelement nicht über die Eigenschaft Steuerelementinhalt <\/b>(ControlSource<\/b>) verfügt, der aber zu einer Fehlermeldung führt. Stattdessen prüft die Prozedur im nächsten Schritt, ob Err.Number <\/b>den Wert 0 <\/b>enthält, was dafür spricht, dass bei der Zuweisung kein Fehler aufgetreten ist und die Eigenschaft Steuerelementinhalt <\/b>somit gefüllt ist.<\/p>\n <\/p>\n Es handelt sich also um ein gebundenes Feld, dessen Inhalt in der Vorlage gespeichert werden soll, also stellt die Prozedur die Variable bolFeldSpeichern <\/b>auf den Wert True <\/b>ein.<\/p>\n Sollte bolGebundeneFelder <\/b>den Wert False <\/b>enthalten, sollen nur speziell gekennzeichnete Felder in der Vorlage gespeichert werden.<\/p>\n Die Prozedur prüft also für das aktuelle Steuerelement, ob die Tag<\/b>-Eigenschaft den Wert AlsVorlageSpeichern <\/b>aufweist. In diesem Fall erhält bolFeldSpeichern <\/b>wiederum den Wert True<\/b> (anderenfalls bleibt er False<\/b>).<\/p>\n Da wir nun durch den Wert der Variablen bolFeldSpeichern <\/b>wissen, ob der Inhalt des Steuerelements gespeichert werden soll, können wir die benötigen Werte ermitteln (s. Listing 2). Der Name des Steuerelements landet in strName<\/b>, der Wert in strWert<\/b>.<\/p>\n Listing 2: Speichern des aktuellen Formularinhalts als Vorlage, Teil II<\/span><\/b><\/p>\n Wir prüfen das Steuerelement noch dahingehend, ob es sich dabei um das Kombinationsfeld zur Auswahl der Vorlagen oder um die Schaltfläche cmdVorlageSpeichern<\/b> handelt. Falls nicht, erfolgt der eigentliche Speichervorgang für dieses Steuerelement.<\/p>\n Hier legen wir mit der AddNew<\/b>-Methode einen neuen Datensatz in der Tabelle an und füllen die Felder Vorlage<\/b>, Formularname<\/b>, Steuerelementname <\/b>und Steuerelementinhalt <\/b>mit den Werten der Variablen strVorlage<\/b>, strFormularname<\/b>, strName <\/b>und strWert<\/b>. Schließlich speichert die Update<\/b>-Methode den Datensatz.<\/p>\n Auf die gleiche Weise durchläuft die Prozedur alle Steuerelemente des Formulars und speichert die Inhalte der infrage kommenden Steuerelemente. Schließlich aktualisiert sie die Datensatzherkunft des Kombinationsfeldes cboVorlageAuswaehlen <\/b>und stelle dieses auf die soeben gespeicherte Vorlage ein.<\/p>\n Der Inhalt der Tabelle tblVorlagen <\/b>sieht für eine Vorlage des Beispielformulars frmArtikel <\/b>nun wie in Bild 4 aus.<\/p>\n Bild 4: Die Tabelle tblVorlagen mit einer Beispielvorlage<\/span><\/b><\/p>\n Kombinationsfeld zur Auswahl einer Vorlage<\/b><\/p>\n Schauen wir uns nun das Kombinationsfeld cboVorlageAuswaehlen <\/b>an. Es erhält seine Datensatzherkunft beim öffnen des Formulars durch die Ereignisprozedur, die durch das Ereignis Beim öffnen <\/b>ausgelöst wird (s. Listing 3). Dabei dient der Formularname als Filter für die anzuzeigenden Elemente. Damit jeder Vorlagenname nur einmal angezeigt wird, verwendet die Abfrage hinter SELECT <\/b>das Schlüsselwort DISTINCT<\/b>.<\/p>\n Listing 3: Diese Prozedur wird bei öffnen des Formulars ausgelöst.<\/span><\/b><\/p>\n Auswahl einer Vorlage<\/b><\/p>\n Wenn der Benutzer einen der im Kombinationsfeld enthaltenen Einträge auswählt, löst er damit die Prozedur aus Listing 4 aus.<\/p>\n Listing 4: Prozedur, die nach dem Aktualisieren des Kombinationsfeldes ausgelöst wird<\/span><\/b><\/p>\n Diese öffnet ein Recordset auf Basis der Tabelle tblVorlagen<\/b>, wobei als Filter der Name der Vorlage aus dem Kombinationsfeld sowie der Formularname verwendet werden. Anschließend durchläuft die Prozedur alle Datensätze der Tabelle und prüft dabei zunächst, ob das Feld Steuerelementinhalt <\/b>nicht den Wert Null <\/b>enthält.<\/p>\n Ist der Feldinhalt ungleich Null, trägt die Prozedur den Wert des Feldes Steu-er-elementinhalt <\/b>als Wert des mit dem Feld Steuerelementname <\/b>angegebenen Steuerelements ein.<\/p>\n Vor dem Zuweisen dieses Wertes deaktiviert die Prozedur die Fehlerbehandlung. Warum das Es gibt einige wenige Fälle, bei denen die Zuweisung der Werte nicht gelingt. Der einzige, der beim Testen dieser Funktion aufgefallen ist, war der Fall eines Primärschlüsselwertes mit Autowert. Ein Steuerelement mit einem Autowertfeld als Steuerelementinhalt kann natürlich nicht einfach durch Zuweisen eines Wertes gefüllt werden. Den dadurch ausgelösten Fehler übergeht die Prozedur jedoch durch die Deaktivierung der Fehlerbehandlung.<\/p>\n Kombinationsfeld bei neuem Datensatz leeren<\/b><\/p>\n Das Kombinationsfeld ist gefüllt, wenn der Benutzer soeben einen Eintrag ausgewählt und das Formular mit den enthaltenen Daten gefüllt hat oder wenn der Benutzer soeben den aktuellen Inhalt des Formulars in der Tabelle tblVorlagen <\/b>gespeichert hat. Wenn der Benutzer von hier aus zu einem anderen Datensatz wechselt, soll das Kombinationsfeld wieder geleert werden. Dies erledigt die folgende Ereignisprozedur, die durch das Ereignis Beim Anzeigen <\/b>des Formulars ausgelöst wird:<\/p>\n Speichern bestimmter Felder testen<\/b><\/p>\n Das Beispielformular frmArtikel <\/b>verwendet den Wert True <\/b>für die Boolean<\/b>-Variable bolGebundeneFelder<\/b>, was wie gewünscht funktioniert. Nun möchten wir allerdings auch noch testen, wie die andere Variante funktioniert.<\/p>\n Hier wollen wir manuell festlegen, welche Felder in der Vorlage gespeichert werden sollen. Dazu erhalten alle Felder, die wir berücksichtigen wollen, den Wert AlsVorlageSpeichern <\/b>für die Eigenschaft Marke <\/b>(unter VBA: Tag<\/b>).<\/p>\n Um dies zu testen, erstellen wir eine Kopie des ersten Beispielformulars frmArtikel <\/b>und speichern dieses unter dem Namen frmArtikel_NachTag<\/b>.<\/p>\n Dann markieren Sie alle Steuerelemente, die in der Vorlage gespeichert werden sollen – in diesem Fall die vier Steuer-elemente, welche die Felder Artikelname<\/b>, LieferantID<\/b>, KategorieID <\/b>und Liefereinheit <\/b>als Steuerelementinhalt <\/b>verwenden. Dann tragen Sie für die Eigenschaft Marke <\/b>den Wert AlsVorlageSpeichern <\/b>ein (s. Bild 5).<\/p>\n Bild 5: Festlegen der Felder, die in der Vorlage gespeichert werden sollen<\/span><\/b><\/p>\n Schließlich fehlt noch ein letzter Schritt: Sie müssen den Wert der Variablen bolGebundeneWerte <\/b>im Ereignis Form_Open <\/b>auf den Wert False <\/b>einstellen (s. Listing 5).<\/p>\n Listing 5: Geänderte Version der Prozedur, die beim öffnen des Formulars ausgelöst wird<\/span><\/b><\/p>\n Ein Test, ob dies funk-tioniert, gelingt auf Anhieb.<\/p>\n Nachteil<\/b><\/p>\n Der Nachteil dieser Funktionalität ist, dass Sie für jedes Formular, das Sie damit ausstatten wollen, die entsprechenden Ereignisprozeduren anlegen und füllen müssen.<\/p>\n Wenn Ihnen dann später einfällt, dass Sie den Code der Vorlagen-Funktion ändern möchten, müssen Sie dies für alle Kopien der entsprechenden Prozeduren erledigen.<\/p>\n Also werden wir, wie wir es schon öfter gemacht haben, den Code dieser Lösung in eine eigene Klasse auslagern.<\/p>\n Sie brauchen dann nur noch die beiden Steuerelemente cboVorlageAuswaeh-len <\/b>und cboVorlageSpeichern <\/b>zu dem betroffenen Formular hinzuzufügen und ein paar Zeilen Code in die Ereignisprozedur einzutragen, die durch das Ereignis Beim Laden <\/b>des Formulars ausgelöst wird.<\/p>\n Formularvorlagen-Funktion als wiederverwendbare Klasse<\/b><\/p>\n Wir zeigen hier einmal, wie Sie eine Funktion, die bislang komplett in einem Formular und seinem Klassenmodul verankert ist, in eine Klasse überführen können und wie Sie die Funktionen dann nutzen.<\/p>\n Als Erstes erstellen Sie ein neues Klassenmodul über den Menübefehl Einfügen|Klassenmodul <\/b>des VBA-Editors. Speichern Sie es unter dem Namen clsFormularvorlagen<\/b>.<\/p>\n Kopieren Sie nun alle für die Funktion benötigten Teile aus dem Klassenmodul des Formulars frmArtikel <\/b>in dieses Klassenmodul. Kommentieren Sie vorerst alle Zeilen aus, wir holen diese gleich Schritt für Schritt zurück.<\/p>\n Nun kümmern wir uns um die Boolean-Variable bolGebundeneFelder<\/b>. Diese soll nun nicht mehr als Variable gefüllt werden, sondern als Eigenschaft der Klasse.<\/p>\n Daher ändern wir den Variablennamen zunächst in m_GebundeneFelder <\/b>und ändern den Gültigkeitsbereich auf Private<\/b>:<\/p>\n Damit diese Variable vom Formular aus eingestellt werden kann, legen wir dafür eine Public Property Let<\/b>-Prozedur an:<\/p>\n Wir benötigen noch einige weitere solcher Eigenschaften, um der Klasse mitzuteilen, welches Formular verwendet wird, welches Kombinationsfeld zur Auswahl der Vorlagen dienen soll und welche Schaltfläche zum Speichern der aktuellen Formularinhalte dienen soll.<\/p>\n Die dazu benötigten Variablen sehen so aus und werden allesamt mit dem Schlüsselwort WithEvents <\/b>ausgestattet:<\/p>\n Um diese Variablen von außen füllen zu können, verwenden wir drei entsprechende Public Property Set<\/b>-Prozeduren (s. Listing 6).<\/p>\n Listing 6: Prozeduren zur Entgegennahme der Property Set-Eigenschaften<\/span><\/b><\/p>\n Die Prozeduren weisen das übergebene Objekt jeweils den entsprechenden Objektvariablen zu. Außerdem stellen Sie die Ereigniseigenschaften für alle auszuführenden Ereignisse auf den Wert [Event Procedure] <\/b>ein. Anschließend bauen wir Schritt für Schritt die zuvor im Formular verwendeten Ereignisprozeduren nach – mit dem Unterschied, dass wir diese nun nicht mehr im Klassenmodul des Formulars implementieren, sondern in dem neuen Klassenmodul clsFormularvorlagen <\/b>für die dort deklarierten Objekte m_frm<\/b>, m_cbo <\/b>und m_cmd<\/b>.<\/p>\n Den Start macht die Prozedur, die durch Ereignis Nach Aktualisierung <\/b>des Kombinationsfeldes ausgelöst wird. Um diese anzulegen, wählen Sie im linken Kombinationsfeld oben im Codefenster des Klassenmoduls clsFormularvorlagen <\/b>den Eintrag m_cbo <\/b>aus und rechts den Eintrag AfterUpdate<\/b> (s. Bild 6).<\/p>\n Bild 6: Anlegen von Ereignisprozeduren für Steuerelemente in einer externen Klasse<\/span><\/b><\/p>\n Dies legt den Prozedurrumpf der Ereignisprozedur m_cbo_AfterUpdate <\/b>an. Nun fügen Sie dort den Code ein, der sich aktuell in der Prozedur cboVorlageAuswaehlen_AfterUpdate <\/b>befindet.<\/p>\n Natürlich sind hier ein paar kleinere Anpassungen durchzuführen – wir können ja von hier aus beispielsweise nicht über das Objekt Me <\/b>auf das Formular zugreifen, und auch die Steuerelemente müssen wir anders ansprechen.<\/p>\n Die erste änderung, die den Prozedurnamen betrifft, haben Sie durch das Neuanlegen der Prozedur im Kontext der Variablen m_cbo <\/b>ja bereits erledigt.<\/p>\n Es stören noch die beiden Bezüge auf die Steuerelemente in der SELECT<\/b>-Anweisung (Me!cboVorlageAuswaehlen <\/b>und Me.Name<\/b>). Diese ersetzen Sie durch m_cbo <\/b>und m_frm.Name<\/b>, also die entsprechenden Objekte des Klassenmoduls, die wiederum mit Verweisen auf die tatsächlich im Formular vorhandenen Objekte gefüllt werden (s. Listing 7). Außerdem ersetzen wir dort noch Me.Controls <\/b>durch m_frm.Controls<\/b> (alle änderungen sind im Listing fett abgedruckt).<\/p>\n Listing 7: Die Ereignisprozedur, die nach der Auswahl einer Vorlage ausgeführt wird<\/span><\/b><\/p>\n Der nächste Kandidat ist die Ereignisprozedur cmdVorlageSpeichern_Click<\/b>. Um diese zu ersetzen, legen Sie für das Objekt m_cmd <\/b>ebenfalls die entsprechende Ereignisprozedur an, also m_cmd_Click<\/b>.<\/p>\n In Listing 8 haben wir eine verkürzte Version der neuen Ereignisprozedur abgebildet, wobei alle geänderten Elemente fett gedruckt sind.<\/p>\n Listing 8: Neue Version der Ereignisprozedur zum Speichern einer Vorlage<\/span><\/b><\/p>\n Kombinationsfeld füllen und aktualisieren<\/b><\/p>\n Das Kombinationsfeld wird im Originalformular in der Ereignisprozedur Form_Open <\/b>gefüllt. Dies sparen wir uns, da wir zum Zuweisen auch die Public Property Set<\/b>-Prozedur verwenden können, mit der wir der Klasse das betroffene Formular übergeben. Diese ergänzen wir gegenüber der vorherigen Version wie in Listing 9 um die Zuweisung der Eigenschaft RowSource<\/b>. Außerdem fügen wir hier noch eine If…Then<\/b>-Bedingung hinzu, mit der wir prüfen, ob die Variable m_cbo <\/b>schon gefüllt ist. Dies muss vor der Zuweisung der Eigenschaft Formular <\/b>der Klasse geschehen, anderenfalls erscheint eine entsprechende Meldung.<\/p>\n Listing 9: Die Property Set-Prozedur Formular nimmt auch noch die Anweisung zum Füllen des Kombinationsfeldes auf.<\/span><\/b><\/p>\n Fehlt nur noch die Prozedur, die beim Anzeigen eines neuen Datensatzes ausgelöst wird und die das Kombinationsfeld in diesem Fall leert. Bei diesem ändert sich nur der Prozedurname sowie der Verweis auf das Kombinationsfeld:<\/p>\n Damit ist die Klasse fertiggestellt. Wir müssen diese nur noch in das Formular integrieren. Dazu legen wir ein neues Formular namens ![\"Entwurf](\"..\/fileadmin\/_temp_\/2014_06\/pic_958_002.png\")
<\/p>\n\n
Private Sub <\/span>cmdVorlageSpeichern_Click()\r\n Dim <\/span>db As <\/span>DAO.Database\r\n Dim <\/span>rst As <\/span>DAO.Recordset\r\n Dim <\/span>ctl As <\/span>Control\r\n Dim <\/span>strName As String<\/span>\r\n Dim <\/span>varWert As Variant<\/span>\r\n Dim <\/span>strVorlage As String<\/span>\r\n Dim <\/span>strFormular As String<\/span>\r\n Dim <\/span>bolFeldSpeichern As Boolean<\/span>\r\n Dim <\/span>strTest As String<\/span>\r\n strFormular = Me.Name\r\n If <\/span>Not<\/span> IsNull(Me!cboVorlageAuswaehlen) Then<\/span>\r\n strVorlage = Me!cboVorlageAuswaehlen\r\n Else<\/span>\r\n strVorlage = \"[Neue Vorlage]\"\r\n End If<\/span>\r\n strVorlage = InputBox(\"Geben Sie eine Bezeichnung für die Vorlage ein.\", _\r\n \"Vorlage speichern\", strVorlage)\r\n Set<\/span> db = CurrentDb\r\n db.Execute \"DELETE FROM tblVorlagen WHERE Vorlage = ''\" & strVorlage _\r\n & \"'' AND Formularname = ''\" & strFormular & \"''\", dbFailOnError\r\n Set<\/span> rst = db.OpenRecordset(\"SELECT * FROM tblVorlagen\", dbOpenDynaset)\r\n For Each ctl In Me.Controls\r\n bolFeldSpeichern = False<\/span>\r\n Select Case bolGebundeneFelder\r\n Case <\/span>True<\/span>\r\n On Error Resume Next<\/span>\r\n strTest = ctl.ControlSource\r\n If <\/span>Err.Number = 0 Then<\/span>\r\n bolFeldSpeichern = True<\/span>\r\n End If<\/span>\r\n On Error GoTo<\/span> 0\r\n Case <\/span>False<\/span>\r\n If <\/span>ctl.Tag = \"AlsVorlageSpeichern\" Then<\/span>\r\n bolFeldSpeichern = True<\/span>\r\n End If<\/span>\r\n End Select<\/span>\r\n ...<\/pre>\n![\"Abfrage](\"..\/fileadmin\/_temp_\/2014_06\/pic_958_003.png\")
<\/p>\nDim <\/span>bolGebundeneFelder As Boolean<\/span><\/pre>\n ...\r\n If <\/span>bolFeldSpeichern = True<\/span> Then<\/span>\r\n strName = ctl.Name\r\n varWert = ctl.Value\r\n Select Case strName\r\n Case <\/span>\"cboVorlageAuswaehlen\", \"cmdVorlageSpeichern\"\r\n Case Else<\/span>\r\n rst.AddNew<\/span>\r\n rst!Vorlage = strVorlage\r\n rst!Formularname = strFormular\r\n rst!Steuerelementname = strName\r\n rst!Steuerelementinhalt = varWert\r\n rst.Update\r\n End Select<\/span>\r\n End If<\/span>\r\n Next<\/span> ctl\r\n Me!cboVorlageAuswaehlen.Requery\r\n Me!cboVorlageAuswaehlen = strVorlage\r\nEnd Sub<\/span><\/pre>\n![\"Die](\"..\/fileadmin\/_temp_\/2014_06\/pic_958_004.png\")
<\/p>\nPrivate Sub <\/span>Form_Open(Cancel As Integer<\/span>)\r\n bolGebundeneFelder = True<\/span>\r\n Me!cboVorlageAuswaehlen.RowSource = _\r\n \"SELECT DISTINCT Vorlage FROM tblVorlagen WHERE Formularname = ''\" _\r\n & Me.Name & \"'' ORDER BY Vorlage;\"\r\nEnd Sub<\/span><\/pre>\nPrivate Sub <\/span>cboVorlageAuswaehlen_AfterUpdate()\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 tblVorlagen WHERE Vorlage = ''\" _\r\n & Me!cboVorlageAuswaehlen _\r\n & \"'' AND Formularname = ''\" & Me.Name & \"''\", dbOpenDynaset)\r\n Do While<\/span> Not<\/span> rst.EOF\r\n If <\/span>Not<\/span> IsNull(rst!Steuerelementinhalt) Then<\/span>\r\n On Error Resume Next<\/span>\r\n Me.Controls(rst!Steuerelementname) = rst!Steuerelementinhalt\r\n On Error GoTo<\/span> 0\r\n End If<\/span>\r\n rst.MoveNext<\/span>\r\n Loop<\/span>\r\nEnd Sub<\/span><\/pre>\nPrivate Sub <\/span>Form_Current()\r\n Me!cboVorlageAuswaehlen = Null\r\nEnd Sub<\/span><\/pre>\n![\"Festlegen](\"..\/fileadmin\/_temp_\/2014_06\/pic_958_005.png\")
<\/p>\nPrivate Sub <\/span>Form_Open(Cancel As Integer<\/span>)\r\n bolGebundeneFelder = False<\/span>\r\n Me!cboVorlageAuswaehlen.RowSource = _\r\n \"SELECT DISTINCT Vorlage FROM tblVorlagen WHERE Formularname = ''\" _\r\n & Me.Name & \"'' ORDER BY Vorlage;\"\r\nEnd Sub<\/span><\/pre>\nPrivate <\/span>m_GebundeneFelder As Boolean<\/span><\/pre>\nPublic Property Let <\/span>GebundeneFelder( _\r\n bolGebundeneFelder As Boolean<\/span>)\r\n m_GebundeneFelder = _\r\n bolGebundeneFelder\r\nEnd Property<\/span><\/pre>\nPrivate <\/span>WithEvents m_frm As <\/span>Form\r\nPrivate <\/span>WithEvents m_cbo As <\/span>ComboBox\r\nPrivate <\/span>WithEvents m_cmd As <\/span>CommandButton<\/pre>\nPublic Property Set<\/span> <\/span>Formular(frm As <\/span>Form)\r\n Set<\/span> m_frm = frm\r\n With<\/span> m_frm\r\n .OnCurrent = \"[Event Procedure]\"\r\n End With<\/span>\r\nEnd Property<\/span>\r\nPublic Property Set<\/span> <\/span>Combobox(cbo As <\/span>Combobox)\r\n Set<\/span> m_cbo = cbo\r\n With<\/span> m_cbo\r\n .AfterUpdate = \"[Event Procedure]\"\r\n End With<\/span>\r\nEnd Property<\/span>\r\nPublic Property Set<\/span> <\/span>Commandbutton(cmd As <\/span>Commandbutton)\r\n Set<\/span> m_cmd = cmd\r\n With<\/span> m_cmd\r\n .OnClick = \"[Event Procedure]\"\r\n End With<\/span>\r\nEnd Property<\/span><\/pre>\n![\"Anlegen](\"..\/fileadmin\/_temp_\/2014_06\/pic_958_006.png\")
<\/p>\nPrivate Sub <\/span>m_cbo_AfterUpdate()\r\n ...\r\n Set<\/span> rst = db.OpenRecordset(\"SELECT * FROM tblVorlagen WHERE Vorlage = ''\" _\r\n & m_cbo & \"'' AND Formularname = ''\" _\r\n & m_frm.Name & \"''\", dbOpenDynaset)\r\n ...\r\n m_frm.Controls(rst!Steuerelementname) = rst!Steuerelementinhalt\r\n...\r\nEnd Sub<\/span><\/pre>\nPrivate Sub <\/span>m_cmd_Click()\r\n ...\r\n strFormular = m_frm.Name\r\n If <\/span>Not<\/span> IsNull(m_cbo) Then<\/span>\r\n strVorlage = m_cbo\r\n ...\r\n db.Execute \"DELETE FROM tblVorlagen WHERE Vorlage = ''\" & strVorlage _\r\n & \"'' AND Formularname = ''\" & m_frm.Name & \"''\", dbFailOnError\r\n ...\r\n For Each ctl In m_frm.Controls\r\n bolFeldSpeichern = False<\/span>\r\n Select Case m_GebundeneFelder\r\n ...\r\n Next<\/span> ctl\r\n m_cbo.Requery\r\n m_cbo.Value = strVorlage\r\nEnd Sub<\/span><\/pre>\nPublic Property Set<\/span> <\/span>Formular(frm As <\/span>Form)\r\n Set<\/span> m_frm = frm\r\n With<\/span> m_frm\r\n .OnCurrent = \"[Event Procedure]\"\r\n If <\/span>m_cbo Is Nothing Then<\/span>\r\n MsgBox<\/span> \"Die Eigenschaft Combobox muss vor der Eigenschaft Formular gesetzt werden.\"\r\n Else<\/span>\r\n m_cbo.RowSource = \"SELECT DISTINCT Vorlage FROM tblVorlagen WHERE Formularname = ''\" _\r\n & m_frm.Name & \"'' ORDER BY Vorlage;\"\r\n End If<\/span>\r\n End With<\/span>\r\nEnd Property<\/span><\/pre>\nPrivate Sub <\/span>m_frm_Current()\r\n m_cbo.Value = Null\r\nEnd Sub<\/span><\/pre>\n