![\"Der](\"..\/fileadmin\/_temp_\/2026_04\/pic_1611_001.png\")
<\/p>\nBis jetzt kann unser Filterformular schon eine ganze Menge: Man klickt sich seine Suchbedingungen zusammen und sieht sofort nur noch die passenden Datensätze. Doch sobald man das Formular schließt, ist der mühsam eingestellte Filter wieder weg. Wer denselben Filter morgen erneut braucht, muss alles noch einmal eintippen. Das ändern wir jetzt. In diesem Teil bringen wir dem Filterformular bei, einen fertigen Filter unter einem Namen zu speichern und ihn später mit einem Klick wieder hervorzuholen.<\/b><\/p>\nDie Idee<\/h2>\n
Stellen Sie sich vor, Sie malen ein schönes Bild und legen es in eine Schublade. Wollen Sie es später wieder ansehen, holen Sie es einfach heraus. Genau das machen wir mit unseren Filtern: Wir schreiben die eingestellten Bedingungen in eine Tabelle – das ist unsere Schublade – und können sie jederzeit wieder herausholen. Damit das Ganze aufgeräumt bleibt, bekommt jeder gespeicherte Filter einen Namen, den man sich selbst aussucht, zum Beispiel „Große Kunden“ oder „Geburtstage diesen Monat“.<\/p>\n
Wichtig ist uns dabei eine Sache: Ein gespeicherter Filter soll nicht nur wieder angewendet werden können, sondern auch wieder vollständig im Formular erscheinen – mit allen Feldern, Bedingungen und Werten. So kann man einen alten Filter laden und ihn bei Bedarf noch ein bisschen anpassen, statt ganz von vorn anzufangen.<\/p>\n
Man könnte nun zwei Knöpfe einbauen: einen zum Speichern und einen zum Laden. Doch das würde schnell unübersichtlich. Wo wählt man beim Laden aus mehreren Filtern den richtigen aus? Wie löscht man einen, den man nicht mehr braucht? Deshalb gehen wir einen anderen Weg: Ein einziger Knopf mit der Aufschrift Filter verwalten<\/b> im Fuß des Formulars öffnet ein kleines Fenster, in dem man alles erledigen kann – speichern, laden, umbenennen und löschen. So bleibt der Formularfuß aufgeräumt.<\/p>\n
Wie dieser neue Knopf aussieht, zeigt Bild 1. Er sitzt zwischen den bereits bekannten Schaltflächen zum Anwenden und Zurücksetzen.<\/p>\n
<\/p>\n
Bild 1: Der neue Knopf „Filter verwalten“ öffnet das Verwaltungsfenster<\/span><\/b><\/p>\n Ein Klick darauf öffnet das Verwaltungsfenster frmFilterVerwaltung<\/b> (siehe Bild 2). Links sieht man die Liste der bereits gespeicherten Filter, rechts die Knöpfe für die einzelnen Aktionen. Praktisch: Es werden immer nur die Filter angezeigt, die zu genau diesem Formular gehören – so vermischt sich nichts, wenn man das Filterformular an mehreren Stellen einsetzt.<\/p>\n Bild 2: Das Formular zum Verwalten der Filter<\/span><\/b><\/p>\n Die Prozedur hinter der Schaltfläche frmVerwalten <\/b>lautet wie folgt:<\/p>\n Zum Aufbewahren brauchen wir zwei Tabellen. Die erste, tblFilter<\/b>, merkt sich zu jedem Filter einen Steckbrief: zu welchem Formular er gehört, wie er heißt und wann er angelegt und zuletzt geändert wurde.<\/p>\n Für diese Tabelle haben wir außerdem einen eindeutigen Index über die Felder Formularname<\/b> und Filtername <\/b>definiert, damit keine doppelten Filternamen je Formular vergeben werden können (siehe Bild 3).<\/p>\n Bild 3: Tabelle zum Speichern der Filter<\/span><\/b><\/p>\n Die zweite, tblFilterZeilen<\/b>, speichert die einzelnen Filterzeilen – also welches Feld, welche Bedingung und welcher Wert in jeder Zeile stehen. Weil ein Filter aus mehreren Zeilen bestehen kann, gehören zu einem Steckbrief in der ersten Tabelle mehrere Einträge in der zweiten.<\/p>\n Den Entwurf dieser Tabelle sehen wir in Bild 4.<\/p>\n Bild 4: Tabelle zum Speichern der Filterzeilen eines Filters<\/span><\/b><\/p>\n Damit beim Löschen eines Filters auch seine Zeilen mitverschwinden, verknüpfen wir die beiden Tabellen mit einer Beziehung, die eine sogenannte Löschweitergabe hat. Löscht man den Steckbrief, räumt Access die zugehörigen Zeilen automatisch mit weg (siehe Bild 5).<\/p>\n Bild 5: Tabellen der Lösung und ihre Beziehung<\/span><\/b><\/p>\n Ein kleiner, aber wichtiger Trick steckt bei den Nachschlagefeldern aus dem vorigen Teil. Dort wählt man einen Wert bequem aus einer Liste aus – angezeigt wird zum Beispiel „Stammkunde“, gespeichert wird aber die dahinterliegende Nummer. Genau diese Nummer schreiben wir auch in unsere Schublade.<\/p>\n Beim Hervorholen setzt das Formular die Nummer wieder ein, und die Liste zeigt von selbst wieder den richtigen Text an. So bleibt alles stimmig, selbst wenn sich der angezeigte Text einmal ändert.<\/p>\n Das Fenster zum Verwalten der Filter sehen wir in der Entwurfsansicht in Bild 6.<\/p>\n Bild 6: Entwurf des Formulars zum Verwalten der Filter<\/span><\/b><\/p>\n Klickt man hier auf Aktuellen Filter speichern<\/b>, startet der Speicher-Vorgang für den aktuell definierten Filter.<\/p>\n Die dadurch ausgelöste Prozedur cmdSpeichern_Click<\/b> (siehe Listing 1) besorgt sich zunächst über FilterFormular<\/b> eine Referenz auf das noch geöffnete Filterformular – schließlich liegen die einzustellenden Bedingungen ja dort und nicht im Dialog.<\/p>\n Listing 1: Aufruf des Speichervorgangs für einen Filter<\/span><\/b><\/p>\n Lässt sich das Formular nicht finden, bricht die Prozedur still ab, denn ohne Filterformular gibt es nichts zu speichern.<\/p>\n Danach wird der Name erfragt. Ist in der Liste bereits ein Filter markiert, verwendet die Prozedur dessen Namen als Vorgabe – so lässt sich ein bestehender Eintrag bequem aktualisieren, ohne den Namen erneut eintippen zu müssen. Die InputBox<\/b> zeigt diesen Vorschlag an, und das umschließende Trim<\/b> entfernt überflüssige Leerzeichen am Rand. Gibt der Benutzer keinen Namen ein oder bricht er ab, endet die Prozedur an dieser Stelle.<\/p>\n Bevor gespeichert wird, klärt FilterExistiert<\/b>, ob unter diesem Namen schon ein Filter abgelegt ist. Falls ja, fragt eine Rückfrage, ob er überschrieben werden soll. Verneint der Benutzer, geschieht nichts weiter; bestätigt er, merkt sich die Prozedur das im Kennzeichen bolUeberschreiben<\/b>. Handelt es sich dagegen um einen neuen Namen, bleibt dieses Kennzeichen auf False<\/b> – es wird schlicht ein neuer Filter angelegt.<\/p>\n Die eigentliche Arbeit übergibt die Prozedur nun an das Filterformular, indem sie dessen Funktion FilterSpeichern<\/b> mit Namen und Überschreiben-Kennzeichen aufruft.<\/p>\n Meldet diese Erfolg, baut ListeAktualisieren<\/b> die Liste im Dialog neu auf, und EintragMarkieren<\/b> hebt den soeben gespeicherten Filter darin hervor.<\/p>\n Auf diese Weise sieht der Benutzer sofort, dass sein Filter angekommen ist, und das Fenster bleibt für weitere Aktionen geöffnet.<\/p>\n Das Speichern eines Filters übernimmt die öffentliche Funktion FilterSpeichern<\/b>. Sie erhält zwei Parameter: den vom Benutzer vergebenen Namen sowie ein Kennzeichen, ob ein bereits vorhandener Filter gleichen Namens überschrieben werden darf.<\/p>\n Als Ergebnis liefert sie True<\/b> zurück, wenn das Speichern geklappt hat – so kann der aufrufende Verwaltungsdialog anschließend die Liste aktualisieren. Den ersten Teil des Codes zeigt Listing 2.<\/p>\n Listing 2: Prozedur zum Speichern des Filters, Teil 1<\/span><\/b><\/p>\n Nach den Variablendeklarationen aktiviert On Error GoTo Fehler<\/b> eine Fehlerbehandlung, die am Ende der Funktion steht. Sollte beim Zugriff auf die Tabellen etwas schiefgehen, landet die Ausführung dort und zeigt eine verständliche Meldung, statt mit einem rohen Laufzeitfehler abzustürzen.<\/p>\n Zunächst ermittelt die Funktion über DatentragendesFormularName<\/b> den Namen des Formulars, dessen Datensätze gefiltert werden. Dieser Name dient später als Zuordnung, damit im Verwaltungsdialog nur die Filter des jeweils passenden Formulars erscheinen. Ist gar kein Name für den Filter angegeben, bricht die Funktion mit einem Hinweis ab – ohne Namen lässt sich ein Filter später schließlich nicht wiederfinden.<\/p>\n Der nächste Block klärt, ob unter diesem Namen bereits ein Filter existiert. Die Hilfsfunktion FilterIDErmitteln<\/b> liefert entweder die Kennung eines vorhandenen Filters oder den Wert 0. Findet sie einen Treffer und wurde das Überschreiben nicht ausdrücklich erlaubt, meldet die Funktion, dass der Name schon vergeben ist, und beendet sich. So kann ein bestehender Filter niemals versehentlich überschrieben werden.<\/p>\n Darf hingegen überschrieben werden, räumt die Funktion zunächst auf: Sie löscht alle bisherigen Zeilen dieses Filters aus tblFilterZeilen<\/b> und vermerkt im Steckbrief über GeaendertAm<\/b> den Zeitpunkt der Änderung. Anschließend werden die Zeilen neu geschrieben – so bleibt kein Rest einer früheren Fassung zurück. Gibt es den Filter dagegen noch nicht, legt die Funktion einen frischen Steckbrief an. Bemerkenswert ist hier die Zeile mit rstKopf.Bookmark = rstKopf.LastModified<\/b>: Sie springt zum eben angelegten Datensatz, um dessen automatisch vergebene Kennung FilterID<\/b> auszulesen. Diese Kennung brauchen wir gleich, um die einzelnen Filterzeilen dem richtigen Steckbrief zuzuordnen.<\/p>\n Nun folgt das Herzstück (zweiter Teil der Prozedur FilterSpeichern<\/b>, siehe Listing 3). Zwei ineinander verschachtelte Schleifen durchlaufen alle aktiven Gruppen und deren Zeilen – genau in derselben Systematik, mit der auch das Anwenden eines Filters arbeitet. Für jede Zeile liest die Funktion das gewählte Feld und die Bedingung aus. Nur wenn beide gefüllt sind, gilt die Zeile als echte Filterzeile und wird gespeichert; leere Zeilen überspringt die Schleife stillschweigend.<\/p>\n Listing 3: Prozedur zum Speichern des Filters, Teil 2<\/span><\/b><\/p>\n Beim Auslesen des Vergleichswerts zeigt sich, wie eng das Speichern an die übrige Logik angelehnt ist. Handelt es sich um ein Nachschlagefeld, holt die Funktion den Wert aus dem Auswahl-Kombinationsfeld cboWert<\/b> – und damit die dahinterliegende Nummer, nicht den angezeigten Text.<\/p>\n Andernfalls stammt der Wert aus dem Textfeld txtWert<\/b>; ist dieses leer, wird ersatzweise das Datumsfeld txtDatum<\/b> herangezogen. Nach demselben Muster ermittelt die Funktion einen etwaigen zweiten Wert – nötig bei der Bedingung Ist zwischen<\/b> – aus txtWert2<\/b> beziehungsweise txtDatumA<\/b>. Zusätzlich sichert sie den Datumstyp, damit vordefinierte Zeiträume wie „Diesen Monat“ später korrekt wiederhergestellt werden.<\/p>\n Steht der Datensatz zusammen, wird er mit AddNew<\/b> angelegt, mit den Werten gefüllt und mit Update<\/b> gespeichert. Die Felder GruppeNr<\/b> und Reihenfolge<\/b> halten dabei fest, an welcher Stelle die Zeile stand – diese Angaben sind später beim Laden entscheidend, damit die Zeilen wieder in der richtigen Anordnung erscheinen. Sind alle Zeilen geschrieben, schließt die Funktion das Recordset, meldet mit True<\/b> den Erfolg und ist fertig.<\/p>\n Das Hervorholen eines gespeicherten Filters ist der spannendste Teil, denn hier muss das Formular seinen früheren Zustand exakt nachbauen.<\/p>\n Der Trick dabei ist einfach und clever zugleich: Statt sich etwas Neues auszudenken, tut das Formular beim Laden genau das, was auch ein Mensch täte. Es wählt ein Feld aus, dann eine Bedingung, dann trägt es den Wert ein – Zeile für Zeile. Dadurch ist garantiert, dass sich ein geladener Filter genauso verhält wie ein von Hand eingegebener.<\/p>\n Damit das klappt, ruft die Prozedur FilterLaden<\/b> für jede gespeicherte Zeile dieselben Bausteine auf, die auch bei der normalen Bedienung laufen: erst das Feld setzen und FeldGewaehlt<\/b> aufrufen, dann die Bedingung setzen und BedingungGewaehlt<\/b> aufrufen, und zum Schluss den Wert eintragen.<\/p>\n Die öffentliche Prozedur FilterLaden<\/b> bekommt die Kennung des gewünschten Filters übergeben und baut den früher gespeicherten Zustand vollständig im Formular wieder auf (erster Teil des Codes siehe Listing 4).<\/p>\n Listing 4: Prozedur zum Laden eines Filters, Teil 1<\/span><\/b><\/p>\n Ein zweiter, optionaler Parameter steuert, ob der Filter nach dem Aufbau gleich angewendet werden soll – voreingestellt ist ja, denn in aller Regel möchte man das geladene Ergebnis sofort sehen.<\/p>\n Bevor irgendetwas eingelesen wird, räumt FilterLaden<\/b> das Formular auf. Dafür ruft die Prozedur FilterZuruecksetzenIntern<\/b> auf. Das ist bewusst nicht dieselbe Routine wie hinter dem Zurücksetzen-Knopf: Jene würde nämlich zusätzlich einen leeren Filter an das aufrufende Formular melden und damit kurz alle Datensätze wieder einblenden.<\/p>\n Genau dieses Flackern wollen wir beim Laden vermeiden, deshalb der ausgelagerte Kern, der nur die Anzeige leert, ohne etwas nach außen zu senden.<\/p>\n Anschließend öffnet die Prozedur ein Recordset auf Basis der Tabelle tblFilterZeilen<\/b>, beschränkt auf die gewünschte Filterkennung und sortiert nach GruppeNr<\/b> und Reihenfolge<\/b>. Diese Sortierung ist wichtig: Nur so werden die Zeilen später in genau der Anordnung aufgebaut, in der sie einmal gespeichert wurden.<\/p>\n Enthält der Filter überhaupt keine Zeilen, bricht die Prozedur an dieser Stelle bereits ab.<\/p>\n Jetzt kommt der bereits angesprochene Schalter ins Spiel. Unmittelbar vor der Schleife setzt die Prozedur m_bolLadeModus<\/b> auf True<\/b>. Dadurch unterlässt FeldGewaehlt<\/b> bei jeder Feldauswahl das automatische Einblenden einer leeren Folgezeile.<\/p>\n Würde man darauf verzichten, entstünden nach jeder wiederhergestellten Zeile überflüssige Leerzeilen, und die Zähler für aktive Zeilen gerieten durcheinander. Im Lademodus baut die Prozedur die Struktur stattdessen selbst gezielt auf.<\/p>\n Die Hauptschleife durchläuft alle gespeicherten Zeilen. Zu Beginn liest sie aus jedem Datensatz die Gruppen- und die Zeilennummer. Falls die betreffende Gruppe oder Zeile noch nicht sichtbar ist, blendet die Prozedur sie zunächst ein – und zwar so, wie es auch der Knopf zum Hinzufügen einer ODER-Gruppe täte.<\/p>\n Zwei kleine Schleifen sorgen dafür, dass bei Bedarf mehrere Gruppen oder Zeilen nacheinander aktiviert werden, bis die richtige Position erreicht ist.<\/p>\n Der eigentliche Aufbau folgt danach demselben Weg wie eine Eingabe von Hand, und genau darin liegt der Kniff (siehe Listing 5).<\/p>\n Listing 5: Prozedur zum Laden des Filters, Teil 2<\/span><\/b><\/p>\n Zuerst setzt die Prozedur das Feld und ruft FeldGewaehlt<\/b> auf – damit werden die passende Bedingungsliste erzeugt, ein etwaiges Nachschlagefeld erkannt und dessen Auswahlliste vorbereitet.<\/p>\n Danach setzt sie die Bedingung und ruft BedingungGewaehlt<\/b> auf, wodurch das jeweils richtige Wertfeld eingeblendet wird. Ist ein Datumstyp gespeichert, wird auch dieser gesetzt und mit DatumstypGewaehlt<\/b> verarbeitet. Weil die Prozedur genau die Bausteine der normalen Bedienung nutzt, verhält sich ein geladener Filter am Ende exakt wie ein von Hand eingegebener.<\/p>\n Den Abschluss jeder Zeile bildet das Eintragen der Werte. Diese Aufgabe übernimmt die Hilfsprozedur WertWiederherstellen<\/b>, die den gespeicherten Wert – und bei Ist zwischen<\/b> auch den zweiten Wert – in das jeweils passende Feld schreibt. Bei einem Nachschlagefeld setzt sie die gespeicherte Nummer in das Auswahl-Kombinationsfeld, worauf dieses von selbst wieder den zugehörigen Text anzeigt. Danach rückt die Schleife zum nächsten Datensatz vor.<\/p>\n Ist die Schleife durch, sind alle gespeicherten Zeilen wiederhergestellt – es fehlt aber noch die leere Eingabezeile, die man von der normalen Bedienung gewohnt ist. Deshalb hängt die Prozedur pro Gruppe noch eine leere Folgezeile an, sofern dort überhaupt noch Platz ist.<\/p>\n So lässt sich ein geladener Filter anschließend genauso bequem erweitern, als hätte man ihn gerade selbst eingegeben.<\/p>\n Zum Schluss schaltet FilterLaden<\/b> den Lademodus wieder aus und bringt die Anzeige in einem Rutsch auf den neuesten Stand: AktualisiereFormularHoehe<\/b> passt die Höhe des Formulars an die nun sichtbaren Zeilen an, AktualisiereSchaltflaechen<\/b> schaltet die Knöpfe richtig. War das Anwenden gewünscht, löst die Prozedur abschließend denselben Vorgang aus wie ein Klick auf Filter anwenden<\/b>, sodass im Hintergrund sofort die gefilterten Datensätze erscheinen.<\/p>\n Über allem liegt eine Fehlerbehandlung. Sollte beim Zugriff auf die Tabelle oder beim Aufbau einer Zeile ein Problem auftreten, springt die Ausführung in den Fehlerzweig.<\/p>\n Dort wird zuerst m_bolLadeModus<\/b> wieder auf False gesetzt – das ist wichtig, damit das Formular nicht versehentlich im Lademodus steckenbleibt und danach keine Folgezeilen mehr einblendet – und anschließend eine verständliche Meldung ausgegeben. So bleibt das Filterformular auch im Fehlerfall bedienbar.<\/p>\n Manchmal passt ein einmal vergebener Name nicht mehr recht, und man möchte ihn ändern, ohne den Filter neu anlegen zu müssen. Genau dafür sorgt cmdUmbenennen_Click<\/b> (siehe Listing 6).<\/p>\n Listing 6: Umbenennen eines Filters<\/span><\/b><\/p>\n Zunächst holt sich die Prozedur über MarkierteFilterID<\/b> die Kennung des in der Liste markierten Filters. Ist gar keiner ausgewählt, liefert diese Funktion 0, und ein kurzer Hinweis bittet den Benutzer, zunächst einen Eintrag zu wählen – danach ist Schluss.<\/p>\n Liegt eine gültige Auswahl vor, merkt sich die Prozedur den bisherigen Namen und fragt über eine InputBox<\/b> nach dem neuen. Praktischerweise steht der alte Name dabei schon als Vorschlag im Eingabefeld, sodass man ihn nur anpassen muss. Das umschließende Trim<\/b> entfernt versehentliche Leerzeichen am Rand. Gibt der Benutzer nichts ein oder lässt er den Namen unverändert, bricht die Prozedur ab, denn dann gibt es nichts zu tun.<\/p>\n Bevor der neue Name übernommen wird, prüft FilterExistiert<\/b>, ob er nicht schon von einem anderen Filter belegt ist. Wäre das der Fall, entstünden zwei Filter gleichen Namens – ein Zustand, den die eindeutige Zuordnung in der Tabelle ohnehin verbietet.<\/p>\n In diesem Fall erscheint ein Hinweis, und die Umbenennung unterbleibt. Erst wenn der Name frei ist, schreibt ein UPDATE<\/b>-Befehl den neuen Namen in tblFilter<\/b> und vermerkt zugleich über GeaendertAm<\/b> den Zeitpunkt der Änderung.<\/p>\n Zum Abschluss wird die Liste neu aufgebaut und der umbenannte Eintrag wieder markiert, damit der Benutzer sofort sieht, dass die Änderung angekommen ist.<\/p>\n Filter, die man nicht mehr benötigt, lassen sich über cmdLoeschen_Click<\/b> wieder entfernen (siehe Listing 7).<\/p>\n![\"Das](\"..\/fileadmin\/_temp_\/2026_04\/pic_1611_002.png\")
<\/p>\nPrivate Sub <\/span>cmdVerwalten_Click()\r\n DoCmd.OpenForm \"frmFilterVerwaltung\", , , , , _\r\n acDialog, DatentragendesFormularName()\r\nEnd Sub<\/span><\/pre>\nWohin die Filter wandern<\/h2>\n
![\"Tabelle](\"..\/fileadmin\/_temp_\/2026_04\/pic_1611_003.png\")
<\/p>\n![\"Tabelle](\"..\/fileadmin\/_temp_\/2026_04\/pic_1611_004.png\")
<\/p>\n![\"Tabellen](\"..\/fileadmin\/_temp_\/2026_04\/pic_1611_005.png\")
<\/p>\nEinen Filter in die Schublade legen<\/h2>\n
![\"Entwurf](\"..\/fileadmin\/_temp_\/2026_04\/pic_1611_006.png\")
<\/p>\nPrivate Sub <\/span>cmdSpeichern_Click()\r\n Dim <\/span>frm As <\/span>Form, strName As String<\/span>, bolUeberschreiben As Boolean<\/span>, varVorgabe As Variant<\/span>\r\n Set<\/span> frm = FilterFormular()\r\n If <\/span>frm Is Nothing Then<\/span> Exit Sub<\/span>\r\n varVorgabe = \"\"\r\n If <\/span>Not<\/span> IsNull(Me.lstFilter.Value) Then<\/span>\r\n varVorgabe = Nz(Me.lstFilter.Column(1), \"\") 'Filtername\r\n End If<\/span>\r\n strName = Trim<\/span>(Nz(InputBox(\"Name fuer den Filter:\", \"Filter speichern\", varVorgabe), \"\"))\r\n If <\/span>Len<\/span>(strName) = 0 Then<\/span> Exit Sub<\/span>\r\n If <\/span>FilterExistiert(strName) Then<\/span>\r\n If MsgBox<\/span>(\"Ein Filter '\" & strName & \"' existiert bereits.\" & vbCrLf<\/span> & \"Ueberschreiben?\", _\r\n vbQuestion + vbYesNo, \"Ueberschreiben\") = vbNo Then\r\n Exit Sub<\/span>\r\n End If<\/span>\r\n bolUeberschreiben = True<\/span>\r\n End If<\/span>\r\n If <\/span>frm.FilterSpeichern(strName, bolUeberschreiben) Then<\/span>\r\n ListeAktualisieren\r\n EintragMarkieren strName\r\n End If<\/span>\r\nEnd Sub<\/span><\/pre>\nDie Funktion FilterSpeichern im Detail<\/h2>\n
Public Function <\/span>FilterSpeichern(strName As String<\/span>, bolUeberschreiben As Boolean<\/span>) As Boolean<\/span>\r\n Dim <\/span>db As <\/span>DAO.Database\r\n Dim <\/span>rstKopf As <\/span>DAO.Recordset\r\n Dim <\/span>rstZeile As <\/span>DAO.Recordset\r\n Dim <\/span>lngFilterID As Long<\/span>\r\n Dim <\/span>strFormular As String<\/span>\r\n Dim <\/span>g As Integer<\/span>, z As Integer<\/span>\r\n Dim <\/span>strFeld As String<\/span>, strBedingung As String<\/span>\r\n Dim <\/span>strWert As String<\/span>, strWert2 As String<\/span>, strDatumstyp As String<\/span>\r\n On Error GoTo<\/span> Fehler\r\n strFormular = DatentragendesFormularName()\r\n If <\/span>Len<\/span>(strName) = 0 Then<\/span>\r\n MsgBox<\/span> \"Bitte einen Namen fuer den Filter angeben.\", vbExclamation, \"Name fehlt\"\r\n Exit Function<\/span>\r\n End If<\/span>\r\n Set<\/span> db = CurrentDb\r\n 'Pruefen ob schon ein Filter dieses Namens existiert\r\n lngFilterID = FilterIDErmitteln(strFormular, strName)\r\n If <\/span>lngFilterID > 0 And Not<\/span> bolUeberschreiben Then<\/span>\r\n MsgBox<\/span> \"Ein Filter mit diesem Namen existiert bereits.\", vbExclamation, \"Bereits vorhanden\"\r\n Exit Function<\/span>\r\n End If<\/span>\r\n If <\/span>lngFilterID > 0 Then<\/span>\r\n 'Vorhandene Zeilen entfernen, Kopf aktualisieren\r\n db.Execute \"DELETE FROM tblFilterZeilen WHERE FilterID = \" & lngFilterID, dbFailOnError\r\n db.Execute \"UPDATE tblFilter SET GeaendertAm = Now() \" & \"WHERE FilterID = \" & lngFilterID, dbFailOnError\r\n Else<\/span>\r\n 'Neuen Kopf anlegen\r\n Set<\/span> rstKopf = db.OpenRecordset(\"tblFilter\", dbOpenDynaset)\r\n rstKopf.AddNew<\/span>\r\n rstKopf!Formularname = strFormular\r\n rstKopf!Filtername = strName\r\n rstKopf!Angelegt = Now()\r\n rstKopf!GeaendertAm = Now()\r\n rstKopf.Update\r\n rstKopf.Bookmark = rstKopf.LastModified\r\n lngFilterID = rstKopf!FilterID\r\n rstKopf.Close\r\n End If<\/span>\r\n ...<\/pre>\nVorbereitung und Namensprüfung<\/h2>\n
Neu anlegen oder überschreiben<\/h2>\n
Die einzelnen Filterzeilen schreiben<\/h2>\n
...\r\n 'Zeilen schreiben\r\n Set<\/span> rstZeile = db.OpenRecordset(\"tblFilterZeilen\", dbOpenDynaset)\r\n For g = 1 To m_intAktiveGruppen\r\n For z = 1 To m_intAktiveZeilen(g)\r\n strFeld = Nz(Me(\"cboFeld_\" & g & \"_\" & z).Value, \"\")\r\n strBedingung = Nz(Me(\"cboBedingung_\" & g & \"_\" & z).Value, \"\")\r\n If <\/span>Len<\/span>(strFeld) > 0 And Len<\/span>(strBedingung) > 0 Then<\/span>\r\n 'Wert wie beim Anwenden ermitteln\r\n If <\/span>m_bolAktKombi(g, z) Then<\/span>\r\n strWert = Nz(Me(\"cboWert_\" & g & \"_\" & z).Value, \"\")\r\n Else<\/span>\r\n strWert = Nz(Me(\"txtWert_\" & g & \"_\" & z).Value, \"\")\r\n If <\/span>Len<\/span>(strWert) = 0 Then<\/span>\r\n strWert = Nz(Me(\"txtDatum_\" & g & \"_\" & z).Value, \"\")\r\n End If<\/span>\r\n End If<\/span>\r\n strWert2 = Nz(Me(\"txtWert2_\" & g & \"_\" & z).Value, \"\")\r\n If <\/span>Len<\/span>(strWert2) = 0 Then<\/span>\r\n strWert2 = Nz(Me(\"txtDatumA_\" & g & \"_\" & z).Value, \"\")\r\n End If<\/span>\r\n strDatumstyp = Nz(Me(\"cboDatumstyp_\" & g & \"_\" & z).Value, \"\")\r\n rstZeile.AddNew<\/span>\r\n rstZeile!FilterID = lngFilterID\r\n rstZeile!GruppeNr = g\r\n rstZeile!Reihenfolge = z\r\n rstZeile!Feldname = strFeld\r\n rstZeile!Bedingung = strBedingung\r\n rstZeile!Datumstyp = strDatumstyp\r\n rstZeile!Wert = strWert\r\n rstZeile!Wert2 = strWert2\r\n rstZeile.Update\r\n End If<\/span>\r\n Next<\/span> z\r\n Next<\/span> g\r\n rstZeile.Close\r\n FilterSpeichern = True<\/span>\r\n Exit Function<\/span>\r\nFehler:\r\n MsgBox<\/span> \"Beim Speichern ist ein Fehler aufgetreten:\" & vbCrLf<\/span> & _\r\n Err.Description, vbCr<\/span>itical, \"Fehler\"\r\nEnd Function<\/span><\/pre>\nEinen Filter wieder hervorholen<\/h2>\n
Die Prozedur FilterLaden im Detail<\/h2>\n
Public Sub <\/span>FilterLaden(lngFilterID As Long<\/span>, Optional<\/span> bolAnwenden As Boolean<\/span> = True<\/span>)\r\n Dim <\/span>db As <\/span>DAO.Database\r\n Dim <\/span>rst As <\/span>DAO.Recordset\r\n Dim <\/span>g As Integer<\/span>, z As Integer<\/span>\r\n Dim <\/span>strDatumstyp As String<\/span>\r\n On Error GoTo<\/span> Fehler\r\n 'Formular zuerst leeren - ohne leeren Filter zu senden\r\n FilterZuruecksetzenIntern\r\n Set<\/span> db = CurrentDb\r\n Set<\/span> rst = db.OpenRecordset(\"SELECT * FROM tblFilterZeilen WHERE FilterID = \" & lngFilterID & \" \" & _\r\n \"ORDER BY GruppeNr, Reihenfolge\", dbOpenSnapshot)\r\n If <\/span>rst.EOF Then<\/span>\r\n rst.Close\r\n Exit Sub<\/span>\r\n End If<\/span>\r\n 'Lademodus aktiv: FeldGewaehlt blendet keine Folgezeile ein\r\n m_bolLadeModus = True<\/span>\r\n Do While<\/span> Not<\/span> rst.EOF\r\n g = rst!GruppeNr\r\n z = rst!Reihenfolge\r\n 'Bei Bedarf Gruppe aktivieren (analog cmdODERHinzufuegen)\r\n Do While<\/span> g > m_intAktiveGruppen\r\n m_intAktiveGruppen = m_intAktiveGruppen + 1\r\n m_intAktiveZeilen(m_intAktiveGruppen) = 1\r\n ZeileEinblenden m_intAktiveGruppen, 1\r\n Loop<\/span>\r\n 'Bei Bedarf Zeile dieser Gruppe einblenden\r\n Do While<\/span> z > m_intAktiveZeilen(g)\r\n m_intAktiveZeilen(g) = m_intAktiveZeilen(g) + 1\r\n ZeileEinblenden g, m_intAktiveZeilen(g)\r\n Loop<\/span>\r\n ...<\/pre>\nErst aufräumen, dann laden<\/h2>\n
Private Sub <\/span>FilterZuruecksetzenIntern()\r\n Dim <\/span>i As Integer<\/span>\r\n Dim <\/span>j As Integer<\/span>\r\n 'Alle Felder leeren\r\n For i = 1 To cMaxGruppen\r\n For j = 1 To cMaxZeilen\r\n Me(\"cboFeld_\" & i & \"_\" & j).Value = Null\r\n Me(\"cboBedingung_\" & i & \"_\" & j).Value = Null\r\n Me(\"cboBedingung_\" & i & \"_\" & j).Enabled = False<\/span>\r\n Me(\"cboDatumstyp_\" & i & \"_\" & j).Value = Null\r\n Me(\"txtWert_\" & i & \"_\" & j).Value = Null\r\n Me(\"txtWert_\" & i & \"_\" & j).Left<\/span> = 4440\r\n Me(\"txtDatum_\" & i & \"_\" & j).Value = Null\r\n Me(\"txtDatum_\" & i & \"_\" & j).Left<\/span> = 6560\r\n Me(\"txtDatumA_\" & i & \"_\" & j).Value = Null\r\n Me(\"txtWert2_\" & i & \"_\" & j).Value = Null\r\n Me(\"cboJaNein_\" & i & \"_\" & j).Value = Null\r\n Me(\"cboWert_\" & i & \"_\" & j).Value = Null\r\n m_lngAktFeldtyp(i, j) = 0\r\n m_bolAktKombi(i, j) = False<\/span>\r\n Next<\/span> j\r\n m_intAktiveZeilen(i) = 1\r\n Next<\/span> i\r\n AlleZeilenAusblenden\r\n m_intAktiveGruppen = 1\r\n m_intAktiveZeilen(1) = 1\r\n ZeileEinblenden 1, 1\r\n cmdODERHinzufuegen.Visible = False<\/span>\r\n cmdZuruecksetzen.Enabled = False<\/span>\r\n cmdAnwenden.Enabled = False<\/span>\r\n AktualisiereFormularHoehe\r\nEnd Sub<\/span><\/pre>\nDer Lademodus verhindert Chaos<\/h2>\n
Zeile für Zeile wiederherstellen<\/h2>\n
...\r\n 'Denselben Weg gehen wie bei manueller Eingabe: Feld -> FeldGewaehlt -> Bedingung -> BedingungGewaehlt\r\n Me(\"cboFeld_\" & g & \"_\" & z).Value = Nz(rst!Feldname, \"\")\r\n FeldGewaehlt g, z\r\n Me(\"cboBedingung_\" & g & \"_\" & z).Value = Nz(rst!Bedingung, \"\")\r\n BedingungGewaehlt g, z\r\n 'Datumstyp setzen falls vorhanden\r\n strDatumstyp = Nz(rst!Datumstyp, \"\")\r\n If <\/span>Len<\/span>(strDatumstyp) > 0 Then<\/span>\r\n Me(\"cboDatumstyp_\" & g & \"_\" & z).Value = strDatumstyp\r\n DatumstypGewaehlt g, z\r\n End If<\/span>\r\n 'Werte eintragen\r\n WertWiederherstellen g, z, Nz(rst!Wert, \"\"), Nz(rst!Wert2, \"\")\r\n rst.MoveNext<\/span>\r\n Loop<\/span>\r\n rst.Close\r\n 'Pro Gruppe eine leere Folge-Eingabezeile anhaengen, damit sich der geladene Filter wie ein manuell eingegebener\r\n 'weiter bearbeiten laesst (sofern noch Platz in der Gruppe).\r\n For g = 1 To m_intAktiveGruppen\r\n If <\/span>m_intAktiveZeilen(g) < cMaxZeilen Then<\/span>\r\n m_intAktiveZeilen(g) = m_intAktiveZeilen(g) + 1\r\n ZeileEinblenden g, m_intAktiveZeilen(g)\r\n End If<\/span>\r\n Next<\/span> g\r\n 'Lademodus beenden, Zustand gebuendelt aktualisieren\r\n m_bolLadeModus = False<\/span>\r\n AktualisiereFormularHoehe\r\n AktualisiereSchaltflaechen\r\n 'Optional sofort anwenden\r\n If <\/span>bolAnwenden Then<\/span>\r\n cmdAnwenden_Click\r\n End If<\/span>\r\n Exit Sub<\/span>\r\nFehler:\r\n m_bolLadeModus = False<\/span>\r\n MsgBox<\/span> \"Beim Laden ist ein Fehler aufgetreten:\" & vbCrLf<\/span> & Err.Description, vbCr<\/span>itical, \"Fehler\"\r\nEnd Sub<\/span><\/pre>\nDen letzten Schliff geben<\/h2>\n
Wenn etwas schiefgeht<\/h2>\n
Einen Filter umbenennen<\/h2>\n
Private Sub <\/span>cmdUmbenennen_Click()\r\n Dim <\/span>lngID As Long<\/span>\r\n Dim <\/span>strAlt As String<\/span>\r\n Dim <\/span>strNeu As String<\/span>\r\n lngID = MarkierteFilterID()\r\n If <\/span>lngID = 0 Then<\/span>\r\n MsgBox<\/span> \"Bitte einen Filter aus der Liste waehlen.\", vbExclamation, \"Kein Filter gewaehlt\"\r\n Exit Sub<\/span>\r\n End If<\/span>\r\n strAlt = Me.lstFilter.Column(1)\r\n strNeu = Trim<\/span>(Nz(InputBox(\"Neuer Name:\", \"Filter umbenennen\", strAlt), \"\"))\r\n If <\/span>Len<\/span>(strNeu) = 0 Or strNeu = strAlt Then<\/span> Exit Sub<\/span>\r\n If <\/span>FilterExistiert(strNeu) Then<\/span>\r\n MsgBox<\/span> \"Ein Filter '\" & strNeu & \"' existiert bereits.\", vbExclamation, \"Bereits vorhanden\"\r\n Exit Sub<\/span>\r\n End If<\/span>\r\n CurrentDb.Execute \"UPDATE tblFilter SET Filtername = '\" & Replace<\/span>(strNeu, \"'\", \"''\") & \"', GeaendertAm = Now() \" & _\r\n \"WHERE FilterID = \" & lngID, dbFailOnError\r\n ListeAktualisieren\r\n EintragMarkieren strNeu\r\nEnd Sub<\/span><\/pre>\nEinen Filter löschen<\/h2>\n
Private Sub <\/span>cmdLoeschen_Click()\r\n Dim <\/span>lngID As Long<\/span>\r\n