<\/p>\n
Der Benutzer einer Access-Datenbank will sich nicht damit beschäftigen, Where-Ausdrücke zu definieren, mit denen er die Daten seiner Datenbank filtern kann. Er braucht aussagekräftige Bezeichnungen, mit denen er die gewünschten Daten erhält – am besten mit nicht viel mehr als einem Mausklick. Das ist eine schöne Aufgabe: Also statten wir unsere Anwendung mit einer solchen Möglichkeit aus, die der Benutzer sogar noch mit selbst angewendeten Filterkriterien anreichern kann. Und das, ohne auch nur einen Hauch von SQL zu beherrschen.<\/b><\/p>\nAusgangsdatenbank<\/h2>\n
Die Beispieldatenbank enthält eine Tabelle tblKunden <\/b>und eine Tabelle tblAnreden<\/b>, wobei die Tabelle tblKunden <\/b>über die Fremdschlüsselfelder LieferAnrede <\/b>und RechnungAnrede <\/b>mit der Tabelle tblAnreden <\/b>verknüpft ist. Zusätzlich haben wir eine Abfrage namens qryKunden <\/b>angelegt, welche die beiden Tabellen tblKunden <\/b>und tblAnreden <\/b>zusammenfasst. Dabei haben wir in dieser Abfrage die beiden Felder LieferAnredeID <\/b>und RechnungAnredeID <\/b>der Tabelle tblKunden <\/b>weggelassen und dafür die Bezeichnung der Anreden aus der Tabelle tblAnreden <\/b>hinzugefügt. Diese Abfrage dient als Datenherkunft eines Unterformulars namens sfmKundenfilter<\/b>. Die Felder haben wir vollständig in den Detailbereich der Entwurfsansicht gezogen. Damit das Unterformular die Daten in der Datenblattansicht anzeigt, stellen Sie die Eigenschaft Standardansicht <\/b>auf diesen Wert ein. Das Unterformular haben wir in ein Hauptformular namens frmKundenfilter <\/b>gezogen, das neben diesem Unterformular natürlich noch die Steuer-elemente zum Anwenden der Filter enthalten soll. Dieser Aufbau sieht wie in Bild 1 aus.<\/p>\n
![\"Basisausstattung](\"..\/fileadmin\/_temp_\/2017_03\/pic_1087_001.png\")
<\/p>\n
Bild 1: Basisausstattung des Formulars frmKundenfilter samt Unterformular sfmKundenfilter<\/span><\/b><\/p>\n Das Ziel ist nun, dem Hauptformular ein Kombinationsfeld hinzuzufügen, mit dem der Benutzer einen vordefinierten Filter auswählen kann. Hat er diesen ausgewählt, soll der Filter direkt auf die Daten im Unterformular angewendet werden. Das bedeutet, dass wir die Filter auch an irgendeiner Stelle vordefinieren und auch abrufbar machen müssen. Was bietet sich da besser an als eine Tabelle<\/p>\n Die Tabelle, in der wir die Filterkriterien speichern wollen, heißt tblFormularfilter <\/b>und ist wie in der Entwurfsansicht aus Bild 2 aufgebaut. Neben dem Primärschlüsselfeld enthält die Tabelle drei Felder:<\/p>\n Bild 2: Tabelle zum Speichern der Filterkriterien<\/span><\/b><\/p>\n Da jede Bezeichnung nur einmal für jedes Formular verwendet werden soll, legen wir außerdem noch einen eindeutigen Index über die beiden Felder Bezeichnung<\/b> und Formularname <\/b>fest (s. Bild 3).<\/p>\n Bild 3: Eindeutiger Index über die beiden Felder Bezeichnung und Formularname<\/span><\/b><\/p>\n Um gleich mit dieser Tabelle arbeiten zu können, geben wir ein paar Beispiele für Filterkriterien in die Datenblattansicht der Tabelle ein (s. Bild 4).<\/p>\n Bild 4: Die Tabelle tblFormularfilter mit einigen Beispieldatensätzen<\/span><\/b><\/p>\n Nun wollen wir das Kombinationsfeld zum Filtern der Daten des Unterformulars nach einem der vordefinierten Filter hinzufügen. Dazu legen Sie ein einfaches Kombinationsfeld im oberen Bereich des Formulars an und nennen es cboFormularfilter<\/b>. Tragen Sie für die Eigenschaft Datensatzherkunft<\/b> des Kombinationsfeldes die Abfrage tblFormularfilter <\/b>ein. Stellen Sie für die Eigenschaft Spaltenanzahl <\/b>den Wert 3 <\/b>und für die Eigenschaft Spaltenbreiten <\/b>den Wert 0cm;;0cm <\/b>ein (s. Bild 5). Was bedeuten diese Werte Als Datensatzherkunft verwenden wir die Tabelle tblFormularfilter<\/b>.<\/p>\n Bild 5: Hinzufügen des Kombinationsfeldes zur Auswahl des Filters<\/span><\/b><\/p>\n Wir benötigen das erste Feld als gebundene Spalte, das zweite als anzuzeigenden Wert und das dritte enthält das Filterkriterium, das wir auslesen wollen, wenn der Benutzer einen der Einträge ausgewählt hat. Also teilen wir dem Kombinationsfeld drei Spalten zu, von denen die erste und die dritte die Breite 0cm aufweisen sollen – also quasi ausgeblendet sind. Nur die mittlere Spalte soll erscheinen, und das in voller Breite. Daher finden Sie zwischen den beiden Semikola keine explizite Breitenangabe.<\/p>\n Nun haben wir allerdings in der Tabelle tblFormularfilter <\/b>bereits ein Feld namens Formularname<\/b> hinterlegt, mit dem wir festlegen wollen, für welches Formular der jeweilige Filter verwendet werden kann. Wir können ja durchaus ein Kundenformular, ein Artikelformular oder auch ein Lieferantenformular mit einem solchen Filter ausstatten.<\/p>\n Wie aber filtern wir die Datensatzherkunft eines Kombinationsfeldes nach dem Namen des Formulars, in dem es angezeigt wird Dies erledigen wir am einfachsten, indem wir die Datensatzherkunft beim Laden des Formulars einstellen. Die dazu notwendige Ereignisprozedur wird durch das Ereignis Beim Laden <\/b>ausgelöst und sieht wie folgt aus:<\/p>\n Danach finden wir im Kombinationsfeld bereits alle gewünschten Einträge vor (s. Bild 6).<\/p>\n Bild 6: Kombinationsfeldes zur Auswahl des Filters<\/span><\/b><\/p>\n Nun fehlt als Grundausstattung noch eine Funktion, die den in der Tabelle gespeicherten Filterausdruck nach der Auswahl eines der Einträge des Kombinationsfeldes auf die Daten des Unterformulars anwendet. Diese Prozedur erstellen wir für das Ereignis Nach Aktualisierung <\/b>des Kombinationsfeldes. Sie sieht wie folgt aus:<\/p>\n Die Prozedur ermittelt mit der Eigenschaft Column(2) <\/b>den Wert der dritten Spalte des ausgewählten Eintrags des Kombinationsfeldes und trägt diesen in die Variable strFilter <\/b>ein (zur Erläuterung: der Index der Spalten im Kombinationsfeld startet mit 0<\/b>). Dann weist sie diesen Ausdruck der Eigenschaft Filter <\/b>des Form<\/b>-Objekts des Unterformular-Steuerelements zu und stellt FilterOn <\/b>auf den Wert True <\/b>ein. Das Ergebnis sieht dann beispielsweise wie in Bild 7 aus.<\/p>\n Bild 7: Der Filter in Aktion<\/span><\/b><\/p>\n Nun fehlt noch eine einfache Funktion, mit welcher der Benutzer den Filter leeren und wieder alle Datensätze im Unterformular einblenden kann. Dazu haben wir zwei Möglichkeiten: Entweder wir fügen eine Schaltfläche hinzu, welche den Filter wieder entfernt, oder wir legen im Kombinationsfeld einen Eintrag an, der etwa den Text Bild 8: Schaltfläche zum Deaktivieren des Filters<\/span><\/b><\/p>\n Die Schaltfläche fügen Sie am besten direkt neben dem Kombinationsfeld ein und legen für das Ereignis Beim Klicken <\/b>die folgende Ereignisprozedur an:<\/p>\n Nun kommt der interessante Teil: Sie wollen ja nicht immer, wenn der Benutzer ein neues Filterkriterium wünscht, zur Tastatur greifen und dem Benutzer anschließend eine neue Version der Datenbank zusenden. Es wäre doch toll, wenn der Benutzer selbst seine Filterkriterien zusammenstellen könnte. Den Grundstein dazu haben wir ja bereits gelegt, indem wir eine Tabelle zum Speichern der Filterkriterien angelegt haben – diese lädt natürlich dazu ein, weitere Kriterien hinzuzufügen.<\/p>\n <\/p>\n Nun könnten Sie dem Benutzer grundlegende SQL-Kenntnisse vermitteln, damit er die Abfragekriterien selbst anhand der Felder und der gewünschten Vergleichswerte zusammenstellt. Ab einer gewissen Komplexität kommt der Benutzer auch sicher nicht um diesen Schritt herum. Aber für viele einfache Kriterien kann der Benutzer sich mit den Mitteln der Benutzeroberfläche behelfen: Dabei filtert er einfach selbst die Daten in dem Formular, indem er etwa auf den Pfeil nach unten im Spaltenkopf klickt, dann beispielsweise für ein Textfeld den Eintrag Textfilter|Enthält… <\/b>auswählt und den gewünschten Vergleichswert in das nun erscheinende Feld eingibt (s. Bild 9).<\/p>\n Bild 9: Eingabe von Filterkriterien über die Benutzeroberfläche<\/span><\/b><\/p>\n Was die Wenigsten wissen: Das dadurch angewendete Filterkriterium wird ebenfalls in die Eigenschaft Filter<\/b> des jeweiligen Formulars eingetragen. Sie können dieses also etwa über den Direktbereich ausgeben lassen – zum Beispiel wie in Bild 10.<\/p>\n Bild 10: Ausgabe des aktuellen Filterkriteriums im Direktbereich<\/span><\/b><\/p>\n Das können wir uns natürlich zunutze machen und das Filterkriterium speichern, wenn der Benutzer das gewünschte Ergebnis erhalten soll. Dazu fügen wir eine weitere Schaltfläche mit der Beschriftung Filter speichern <\/b>hinzu. Diese erhält den Namen cmdFilterSpeichern <\/b>und die Prozedur aus Listing 1 für die Ereigniseigenschaft Beim Klicken<\/b>. Die Prozedur ermittelt zunächst den aktuellen Filterausdruck und speichert diesen in der Variablen strFilter<\/b>.<\/p>\n Listing 1: Speichern eines benutzerdefinierten Filters<\/span><\/b><\/p>\n Hat strFilter <\/b>danach die Länge 0<\/b>, war offensichtlich kein Filter aktiviert und die Prozedur wird mit einer entsprechenden Meldung abgebrochen. Eine Variable namens bolGespeichert <\/b>wird auf True <\/b>eingestellt – hat diese am Ende der Prozedur auch noch diesen Wert, wurde erfolgreich gespeichert und es können die zur Anpassung der Benutzeroberfläche nötigen Schritte durchgeführt werden.<\/p>\n Nun fragt die Prozedur per InputBox <\/b>die Bezeichnung für den neuen Filter ab und speichert diese in der Variablen strBezeichnung<\/b>. Außerdem landet noch der Name des aktuellen Formulars in der Variablen strFormularname<\/b>. Hat der Benutzer keinen Wert in die InputBox <\/b>eingegeben oder die Abbrechen<\/b>-Schaltfläche betätigt, ist die Länge der Zeichenkette in der Variablen strBezeichnung <\/b>gleich 0<\/b>. In diesem Fall endet die Prozedur ebenfalls. Anderenfalls holt die Prozedur einen Verweis auf das aktuelle Database<\/b>-Objekt in die Variable db<\/b> und deaktiviert die Fehlerbehandlung. Dies hat den Sinn, dass beim nachfolgenden Versuch, die aktuelle Kombination aus Bezeichnung und Formularname samt Filterausdruck in der Tabelle tblFormularfilter <\/b>zu speichern, ein Fehler auftreten könnte – und zwar, wenn bereits ein Filter mit der angegebenen Bezeichnung für dieses Formular gespeichert wurde. In diesem Fall liefert Err.Number <\/b>in der folgenden If…Then<\/b>-Bedingung den Wert 3022<\/b>, was zum Ausführen des Then<\/b>-Teils dieser Bedingung führt. Hier fragt die Prozedur den Benutzer, ob er den bereits vorhandenen Filter mit dieser Bezeichnung überschreiben möchte. Falls ja, führt die Prozedur per Execute<\/b>-Methode eine entsprechende UPDATE<\/b>-Anweisung aus und aktualisiert den Datensatz mit dem neuen Filterausdruck. Wünscht der Benutzer dies nicht, wurde nichts geändert und bolGespeichert <\/b>erhält den Wert False<\/b>.<\/p>\n Hat bolGespeichert <\/b>hier den Wert True<\/b>, wollen wir noch dafür sorgen, dass der frisch angelegte (oder geänderte) Filterausdruck auch gleich im Kombinationsfeld angezeigt wird. Dazu ermitteln wir per DLookup<\/b>-Funktion den Primärschlüsselwert zu dem Datensatz mit der Bezeichnung und dem Formularnamen und legen diesen in der Variablen lngFilterID <\/b>ab. Danach aktualisieren wir die Datensatzherkunft des Kombinationsfeldes und stellen dieses auf die soeben ermittelte ID ein – wie etwa in Bild 11 zu sehen.<\/p>\n Bild 11: Ein frisch angelegter Filter<\/span><\/b><\/p>\n Mit der Zeit sammeln sich so einige Filter in der Tabelle strFormularfilter<\/b> an (s. Bild 12). Diese soll der Benutzer natürlich auch verwalten können – allein, um nicht mehr benötigte Filter auszusortieren oder Filter umzubenennen und so neu zu strukturieren.<\/p>\n Bild 12: Filtersammlung<\/span><\/b><\/p>\n Dazu fügen wir dem Formular frmKundenfilter<\/b> eine weitere Schaltfläche namens cmdFilterBearbeiten <\/b>hinzu, welche die folgende Ereignisprozedur auslöst:<\/p>\n Der Entwurf des Formulars frmFormularfilter <\/b>sieht wie in Bild 13 aus. Er besteht aus einem Hauptformular mit zwei Textfeldern namens txtSucheBezeichnung <\/b>und txtSucheFilter<\/b>, in die der Benutzer Filterausdrücke für die Felder Bezeichnung<\/b> und Filter <\/b>eingeben kann.<\/p>\n Bild 13: Formular zum Verwalten der Filter in der Entwurfsansicht<\/span><\/b><\/p>\n Außerdem finden Sie dort eine Schaltfläche namens cmdFilterLeeren<\/b>, welche die zuvor genannten Textfelder leert und auch den Filter für das Unterformular zurücksetzt.<\/p>\n Das Unterformular heißt sfmFormularfilter <\/b>und verwendet die Tabelle tblFormularfilter <\/b>als Datenherkunft. Es zeigt alle Felder der Tabelle in der Datenblattansicht an.<\/p>\n Die beiden Textfelder zum Filtern der Datensätze des Unterformulars erwarten die Eingabe des Benutzers und filtern das Unterformular nach jedem getippten Zeichen neu, damit der Benutzer immer direkt das aktuelle Ergebnis sieht.<\/p>\n Zu diesem Zweck finden Sie im Kopf des Klassenmoduls zu diesem Formular die Deklaration zweier Variablen zum Aufnehmen des jeweils aktuellen Textes der beiden Textfelder:<\/p>\n Wenn der Benutzer nun etwa ein Zeichen in das Textfeld txtSucheBezeichnung <\/b>eintippt, löst er das Ereignis Bei änderung <\/b>aus. Dafür haben wir die Ereignisprozedur txtSucheBezeichnung_Change <\/b>hinterlegt, die wie folgt aussieht:<\/p>\n Hier ermitteln wir über die Eigenschaft Text <\/b>des Textfeldes txtSucheBezeichnung <\/b>den aktuellen Inhalt dieses Textfeldes und tragen ihn in die Variable strSucheBezeichnung <\/b>ein. Warum Text <\/b>und nicht einfach Value<\/b> Weil Value <\/b>sich erst nach dem Abschließen der Eingabe etwa durch Verlassen des Textfeldes ändert und wir so nicht nach der Eingabe eines jeden Zeichens neu filtern können. Nach dem Speichern des Vergleichswertes ruft die Prozedur die Routine Suchen <\/b>auf, die wir gleich im Anschluss erläutern.<\/p>\n Zuvor noch ein Blick auf die entsprechende Ereignisprozedur für das Textfeld txtSucheFilter<\/b>. Diese ist analog aufgebaut wie txtBezeichnungFilter_Change<\/b> und speichert den aktuellen Text des Textfeldes in der Variablen strSucheFilter<\/b>:<\/p>\n Warum aber speichern wir die Inhalte der Text-Eigenschaft jeweils in lokalen Variablen, bevor wir die Suchen<\/b>-Funktion aufrufen Wir könnten doch auch von der Suchen-Funktion auf die entsprechenden Werte der Textfelder zugreifen Leider nein: Auf die Text<\/b>-Eigenschaft kann man nur zugreifen, wenn das jeweilige Textfeld gerade den Fokus besitzt. Wir müssten also in der Routine zum Suchen erst noch den Fokus verschieben, was zu unnötigen Komplikationen führt. Da speichern wir die aktuellen Werte doch lieber schnell in zwei Variablen.<\/p>\n Beide Prozeduren rufen danach die Routine Suchen<\/b> auf, die wir in Listing 2 abgebildet haben. Diese prüft zunächst, ob strSucheBezeichnung <\/b>eine Zeichenkette mit mehr als 0 <\/b>Zeichen enthält. In diesem Fall fügt sie zur Variablen strSuchausdruck <\/b>einen Teil hinzu, der beispielsweise so aussieht:<\/p>\n Listing 2: Durchsuchen der Filter nach verschiedenen Kriterien<\/span><\/b><\/p>\n Das Gleiche geschieht danach für die String<\/b>-Variable strSucheFilter<\/b>. Wenn beide Textfelder bereits einen Wert enthalten, sind auch die beiden String<\/b>-Variablen gefüllt, wodurch dann zwei Ausdrücke in der Variablen strSuchausdruck <\/b>zusammengeführt werden.<\/p>\n Hat strSuchausdruck <\/b>danach also einen Inhalt mit der Länge größer 0<\/b>, wird das führende AND <\/b>vorn im Suchausdruck mit der Mid<\/b>-Funktion abgeschnitten. Dann landet der Suchausdruck in der Eigenschaft Filter <\/b>des Form<\/b>-Objekts des Unterformular-Steuerelements und der Filter wird mit FilterOn = True <\/b>aktiviert. Sollte keine der beiden Variablen strSucheBezeichnung <\/b>und strSucheFilter <\/b>gefüllt sein, wird der Filter mit Filter = „“ <\/b>deaktiviert.<\/p>\n Das Ergebnis sieht dann etwa wie in Bild 14 aus.<\/p>\n Bild 14: Formular zum Verwalten in der Formularansicht<\/span><\/b><\/p>\n Nun haben wir auch diesem Formular eine Schaltfläche namens cmdFilterLeeren<\/b> hinzugefügt, welche beim Anklicken die folgende Prozedur auslösen soll:<\/p>\n Damit werden zunächst die beiden Textfelder txtSucheBezeichnung <\/b>und txtSucheFilter <\/b>geleert und danach die entsprechenden String-Variablen. Der anschließende Aufruf der Suchen<\/b>-Routine sorgt dann dafür, dass das Unterformular wieder alle Datensätze anzeigt.<\/p>\n Wir müssen nun noch entscheiden, ob das Formular zur Verwaltung der Formularfilter immer alle Datensätze für die aktuelle Datenbank anzeigen soll oder ob der Benutzer nur die Datensätze sehen soll, die sich auf das Formular beziehen, von dem aus er das Formlar zur Filterverwaltung aufgerufen hat. Letzteres scheint logischer zu sein, denn wieso sollte man Filter verwalten, die sich auf mehrere Formulare beziehen<\/p>\n Also stellen wir das Formular so ein, dass das Unterformular gleich zu Beginn nur die Filter zum aktuellen Formular anzeigt. Dazu leeren wir einfach die Eigenschaft Datenherkunft <\/b>des Formulars und weisen beim Laden des Formulars eine entsprechend gefilterte Datenherkunft zu. Warum auf diesem Wege und nicht durch Anpassen des Filterausdrucks Weil wir dann mit den anderen per Textfeld zu setzenden Filtern durcheinander kommen.<\/p>\nZiel der Lösung<\/h2>\n
Tabelle zum Speichern der Filter<\/h2>\n
![\"Tabelle](\"..\/fileadmin\/_temp_\/2017_03\/pic_1087_002.png\")
<\/p>\n\n
![\"Eindeutiger](\"..\/fileadmin\/_temp_\/2017_03\/pic_1087_010.png\")
<\/p>\n![\"Die](\"..\/fileadmin\/_temp_\/2017_03\/pic_1087_003.png\")
<\/p>\nEinbau des Filterkombinationsfeldes<\/h2>\n
![\"Hinzufügen](\"..\/fileadmin\/_temp_\/2017_03\/pic_1087_004.png\")
<\/p>\nNach Formular filtern<\/h2>\n
Private Sub <\/span>Form_Load()\r\n Me!cboFormularfilter.RowSource = _\r\n \"SELECT * FROM tblFormularfilter WHERE Formularname = ''\" & Me.Name & \"''\"\r\nEnd Sub<\/span><\/pre>\n![\"Kombinationsfeldes](\"..\/fileadmin\/_temp_\/2017_03\/pic_1087_005.png\")
<\/p>\nFilterfunktion hinzufügen<\/h2>\n
Private Sub <\/span>cboFormularfilter_AfterUpdate()\r\n Dim <\/span>strFilter As String<\/span>\r\n strFilter = Me!cboFormularfilter.Column(2)\r\n Me!sfmKundenfilter.Form.Filter = strFilter\r\n Me!sfmKundenfilter.Form.FilterOn = True<\/span>\r\nEnd Sub<\/span><\/pre>\n![\"Der](\"..\/fileadmin\/_temp_\/2017_03\/pic_1087_006.png\")
<\/p>\nFilter leeren<\/h2>\n
![\"Schaltfläche](\"..\/fileadmin\/_temp_\/2017_03\/pic_1087_007.png\")
<\/p>\nPrivate Sub <\/span>cmdFilterLeeren_Click()\r\n Me!cboFormularfilter = Null\r\n Me!sfmKundenfilter.Form.Filter = \"\"\r\nEnd Sub<\/span><\/pre>\nEigene Filter definieren<\/h2>\n
![\"Eingabe](\"..\/fileadmin\/_temp_\/2017_03\/pic_1087_008.png\")
<\/p>\n![\"Ausgabe](\"..\/fileadmin\/_temp_\/2017_03\/pic_1087_009.png\")
<\/p>\nPrivate Sub <\/span>cmdFilterSpeichern_Click()\r\n Dim <\/span>strBezeichnung As String<\/span>\r\n Dim <\/span>strFilter As String<\/span>\r\n Dim <\/span>db As <\/span>DAO.Database\r\n Dim <\/span>strFormularname As String<\/span>\r\n Dim <\/span>bolGespeichert As Boolean<\/span>\r\n Dim <\/span>lngFilterID As Long<\/span>\r\n strFilter = Me!sfmKundenfilter.Form.Filter\r\n If <\/span>Len<\/span>(strFilter) = 0 Then<\/span>\r\n MsgBox<\/span> \"Es ist kein Filter aktiv.\"\r\n Exit Sub<\/span>\r\n End If<\/span>\r\n bolGespeichert = True<\/span>\r\n strBezeichnung = InputBox(\"Geben Sie eine Bezeichnung für den Filter ein:\", \"Filter speichern\")\r\n strFormularname = Me.Name\r\n If <\/span>Not<\/span> Len<\/span>(strBezeichnung) = 0 Then<\/span>\r\n Set<\/span> db = CurrentDb\r\n On Error Resume Next<\/span>\r\n db.Execute \"INSERT INTO tblFormularfilter(Bezeichnung, Filter, Formularname) VALUES(''\" & strBezeichnung _\r\n & \"'', ''\" & strFilter & \"'', ''\" & strFormularname & \"'')\", dbFailOnError\r\n If <\/span>Err.Number = 3022 Then<\/span>\r\n If MsgBox<\/span>(\"Es gibt bereits einen Filter mit dieser Bezeichnung. überschreiben\", vbYesNo, _\r\n \"Filter überschreiben\") = vbYes Then\r\n db.Execute \"UPDATE tblFormularfilter SET Filter = ''\" & strFilter & \"'' WHERE Bezeichnung = ''\" _\r\n & strBezeichnung & \"'' AND Formularname = ''\" & strFormularname & \"''\", dbFailOnError\r\n Else<\/span>\r\n bolGespeichert = False<\/span>\r\n End If<\/span>\r\n End If<\/span>\r\n If <\/span>bolGespeichert Then<\/span>\r\n lngFilterID = DLookup(\"FilterID\", \"tblFormularfilter\", \"Bezeichnung = ''\" & strBezeichnung _\r\n & \"'' AND Formularname = ''\" & strFormularname & \"''\")\r\n Me!cboFormularfilter.Requery\r\n Me!cboFormularfilter = lngFilterID\r\n End If<\/span>\r\n End If<\/span>\r\nEnd Sub<\/span><\/pre>\n![\"Ein](\"..\/fileadmin\/_temp_\/2017_03\/pic_1087_011.png\")
<\/p>\nFilter verwalten<\/h2>\n
![\"Filtersammlung\"](\"..\/fileadmin\/_temp_\/2017_03\/pic_1087_012.png\")
<\/p>\nPrivate Sub <\/span>cmdFilterBearbeiten_Click()\r\n DoCmd.OpenForm \"frmFormularfilter\", OpenArgs:=Nz(Me.cboFormularfilter, 0)\r\nEnd Sub<\/span><\/pre>\n![\"Formular](\"..\/fileadmin\/_temp_\/2017_03\/pic_1087_014.png\")
<\/p>\nDim <\/span>strSucheBezeichnung As String<\/span>\r\nDim <\/span>strSucheFilter As String<\/span><\/pre>\nPrivate Sub <\/span>txtSucheBezeichnung_Change()\r\n strSucheBezeichnung = Me!txtSucheBezeichnung.Text\r\n Suchen\r\nEnd Sub<\/span><\/pre>\nPrivate Sub <\/span>txtSucheFilter_Change()\r\n strSucheFilter = Me!txtSucheFilter.Text\r\n Suchen\r\nEnd Sub<\/span><\/pre>\nPrivate Sub <\/span>Suchen()\r\n Dim <\/span>strSuchausdruck As String<\/span>\r\n If <\/span>Len<\/span>(strSucheBezeichnung) > 0 Then<\/span>\r\n strSuchausdruck = strSuchausdruck & \" AND Bezeichnung LIKE ''*\" & strSucheBezeichnung & \"*''\"\r\n End If<\/span>\r\n If <\/span>Len<\/span>(strSucheFilter) > 0 Then<\/span>\r\n strSuchausdruck = strSuchausdruck & \" AND Filter LIKE ''*\" & strSucheFilter & \"*''\"\r\n End If<\/span>\r\n If <\/span>Len<\/span>(strSuchausdruck) > 0 Then<\/span>\r\n strSuchausdruck = Mid<\/span>(strSuchausdruck, 6)\r\n Me!sfmFormularfilter.Form.Filter = strSuchausdruck\r\n Me!sfmFormularfilter.Form.FilterOn = True<\/span>\r\n Else<\/span>\r\n Me!sfmFormularfilter.Form.Filter = \"\"\r\n End If<\/span>\r\nEnd Sub<\/span><\/pre>\n AND Bezeichnung LIKE ''*Liefer*''<\/pre>\n
![\"Formular](\"..\/fileadmin\/_temp_\/2017_03\/pic_1087_013.png\")
<\/p>\nPrivate Sub <\/span>cmdFilterLeeren_Click()\r\n Me!txtSucheBezeichnung = Null\r\n Me!txtSucheFilter = Null\r\n strSucheBezeichnung = \"\"\r\n strSucheFilter = \"\"\r\n Suchen\r\nEnd Sub<\/span><\/pre>\nFilter für alle oder nur für Formulare<\/h2>\n