<\/p>\n
Formulare in der Datenblattansicht bieten alle Filter- und Sortiermöglichkeiten, die das Benutzerherz begehrt. Allerdings sind diese nicht unbedingt immer schnell erreichbar – hier und da könnte es noch ein wenig fixer gehen. Ein Beispiel ist ein Filter, der nur die Datensätze anzeigt, die den Wert des aktuell markierten Feldes im jeweiligen Feld enthalten. Wenn Sie also etwa eine Reihe von Artikeln anzeigen, die einer bestimmten Kategorie angehören und schnell nur noch die Artikel dieser Kategorie sehen wollen, benötigen Sie dazu mehrere Mausklicks. Dieser Beitrag zeigt, wie Sie verschiedene Suchen mit einem einfachen Klick auf eine Schaltfläche erledigen.<\/b><\/p>\n
Die Datenblattansicht von Access-Formularen bietet eine Reihe von Möglichkeiten, schnell nach Daten zu suchen oder diese zu sortieren.<\/p>\n
Dazu klicken Sie einfach auf das nach unten zeigende Dreieck rechts im Spaltenkopf der jeweiligen Spalte. Hier sehen Sie auf Anhieb zwei Einträge zum Sortieren in verschiedenen Richtungen oder zum Selektieren verschiedener, im aktuellen Feld enthaltener Werte (s. Bild 1).<\/p>\n
![\"Filtern](\"..\/fileadmin\/_temp_\/2017_01\/pic_1072_001.png\")
<\/p>\n
Bild 1: Filtern nach allen vorhandenen Werten<\/span><\/b><\/p>\n Der Untereintrag Textfilter <\/b>liefert etwa für Textfelder weitere Möglichkeiten: Hier können Sie beispielsweise nach Datensätzen suchen, deren markiertes Feld einen benutzerdefinierten Wert enthält. Bei Textfeldern können hier etwa die Vergleichsoperatoren Gleich<\/b>, Nicht gleich<\/b>, Beginnt mit<\/b>, Beginnt nicht mit<\/b>, Enthält <\/b>und weitere verwendet werden (s. Bild 2). Andere Felddatentypen halten dem Datentyp entsprechende Vergleichskriterien bereit.<\/p>\n Bild 2: Filtern nach benutzerdefinierten Vergleichswerten<\/span><\/b><\/p>\n Was aber hier fehlt, ist die einfache Möglichkeit, schnell alle Einträge anzuzeigen, die den gleichen Wert im zurzeit markierten Feld aufweisen wie der aktuelle Datensatz. Und genau diese Funktion wollen wir nun nachrüsten. Für das Feld Artikelname macht dies natürlich recht wenig Sinn, aber beim Lieferanten oder bei der Kategorie finden sich schnell Einsatzmöglichkeiten.<\/p>\n Warum nicht beim Artikelnamen Nun: Dabei handelt es sich um ein Feld mit einem eindeutigen Index. Da nur jeweils ein Datensatz mit dem aktuellen Wert vorhanden ist, macht es wenig Sinn, danach zu filtern … außer natürlich, wenn Sie etwa aus Gründen der übersicht nur diesen einen Datensatz anzeigen möchten. Also nehmen wir diese einfache Variante einfach mit hinzu. <\/p>\n Später wollen wir jedoch gerade für Textfelder noch eine schnelle Filterfunktion hinzufügen, mit der Sie sogar alle Datensätze anzeigen können, die den aktuell markierten Wert enthalten.<\/p>\n Der Filter soll dann wie im Beispiel aus Bild 3 funktionieren. Der Benutzer markiert den Wert, nach dem die Daten gefiltert werden sollen, und klickt auf die Schaltfläche Schneller Filter<\/b>. Daraufhin werden alle Datensätze ausgeblendet, deren Inhalt im betroffenen Feld nicht mit dem Vergleichswert übereinstimmt. Eine weitere Schaltfläche soll den Filter wieder deaktivieren.<\/p>\n Bild 3: So soll der Filter nach einem Feldwert arbeiten.<\/span><\/b><\/p>\n Beginnen wir doch einfach mit einer Schaltfläche, die wir cmdSchnellerFilter <\/b>nennen und mit der Beschriftung Schneller Filter <\/b>versehen. Diese soll die Datenherkunft des Unterformulars in dem Formular, in dem sich die Schaltfläche befindet, nach dem Wert des zuvor markierten Feldes filtern. Wie sich herausstellt, ist dies gar nicht so einfach, denn wir finden erst gar nicht heraus, welches Feld gerade überhaupt markiert war. <\/p>\n Unsere erste Idee war es nämlich, das Steuerelement mit dem besagten Filtervergleichswert einfach über den Ausdruck Screen.PreviousControl.Name <\/b>zu ermitteln und diesen per Debug.Print <\/b>im Direktbereich auszugeben. Dazu haben wir die Beim Klicken<\/b>-Ereignisprozedur der Schaltfläche cmdSchnellerFilter <\/b>wie folgt ausgestattet:<\/p>\n Das Ergebnis lieferte aber leider nicht das gesuchte Steuerelement, sondern den Namen des Unterformulars:<\/p>\n Wir stehen nun also vor dem Problem, zwar zum Zeitpunkt den Inhalt des zuletzt aktivierten Feldes im Unterformular zu benötigen, dieses aber nicht mehr zu kennen.<\/p>\n Es gibt nun diverse Möglichkeiten, die gewünschte Information zu erhalten. Eine davon lautet, irgendwo eine Variable vorzuhalten, die wir mit einem Verweis auf das jeweils aktive Steuerelement des Unterformulars füllen und dann beim Mausklick auf die Schaltfläche cmdSchnellerFilter <\/b>über diese Variable auf das Feld und seinen Inhalt zugreifen. Das ist allerdings mit einigem Aufwand verbunden, wenn wir es auf dem einfachen Weg erledigen. Dieser sieht vor, eine Variable zum Speichern des zuletzt verwendeten Feldes im Klassenmodul des Hauptformulars zu deklarieren. Außerdem legen wir für jedes Steuerelement im Unterformular eine Ereigniseigenschaft namens Bei Fokuserhalt <\/b>an und hinterlegen dafür eine Ereignisprozedur, welche einen Verweis auf das jeweilige Steuerelement in die Variable im Klassenmodul des Hauptformulars einträgt.<\/p>\n Mit der Ereignisprozedur Beim Klicken <\/b>der Schaltfläche cmdSchnellerFilter <\/b>können Sie dann aus der Variablen den Wert ermitteln und nach dem Feld, an welches das Steuerelement aus der Variablen gebunden ist, filtern.<\/p>\n Wir müssen nur für jedes betroffene Steuerelement im Unterformular eine entsprechende Ereignisprozedur für das Ereignis Bei Fokuserhalt <\/b>hinterlegen. Und ebenso für alle Steuerelemente der Unterformulare in anderen Formularen, die Sie mit der Funktion ausstatten möchten.<\/p>\n Nun ist Access im Unternehmen aber weniger bekannt dafür, den Leser mit Fleißarbeit auszustatten. Wir suchen eher nach einer Lösung, die der Leser in wenigen Minuten implementieren kann. Also greifen wir, wie schon ein paar Mal geschehen, auf Klassenmodule zurück, in denen wir die gewünschte Funktionalität unterbringen. Das Klassenmodul des Hauptformulars soll nur mit wenigen Zeilen Code ausgestattet werden, die zum größten Teil in der Ereignisprozedur Form_Load <\/b>landen. Insgesamt sieht der benötigte Code wie folgt aus. Als Erstes benötigen wir eine Objektvariable, welche den Verweis auf die gleich noch erläuterte Klasse clsFastFilter <\/b>aufnimmt:<\/p>\n Als Nächstes folgt dann die Ereignisprozedur Form_Load<\/b>, die wir folgt aussieht:<\/p>\n Sie erstellt zunächst ein neues Objekt auf Basis der Klasse clsFastFilter<\/b> und speichert den Verweis darauf in der Variablen objFastFilter<\/b>. Dann weist sie den beiden Eigenschaften Subform <\/b>und FastFilterButton <\/b>Verweise auf das Unterformular mit den zu durchsuchenden Datensätzen (Achtung: Wenn Sie Klassen erstellen, die Objekte wie etwa Formulare oder die enthaltenen Steuerelemente referenzieren und deren Ereignisse implementieren wollen, muss für das jeweilige Formular (und somit auch für Unterformulare) auch ein Klassenmodul vorliegen! In unserem Fall haben wir etwa für das Unterformular mit dem Datenblatt noch kein Klassenmodul angelegt. Dies erfolgt automatisch, sobald Sie für eine der Ereigniseigenschaften des Formulars ein Ereignis anlegen und dieses über die Schaltfläche mit den drei Punkten im VBA-Editor öffnen. Sie können dies aber auch durch einfaches Einstellen der Eigenschaft Enthält Modul <\/b>erledigen. Diese Eigenschaft finden Sie im Reiter Andere<\/b> des jeweiligen Formulars (s. Bild 4).<\/p>\n Bild 4: Hinzufügen eines Klassenmoduls per Eigenschaft<\/span><\/b><\/p>\n Diese Klasse ist die Steuerzentrale der Lösung. Sie nimmt die Verweise auf die beteiligten Elemente entgegen, also das Unterformular sowie die Schaltfläche zum Auslösen des Filters. Das Unterformular wird mit der folgenden Variablen referenziert, die im Kopf des Klassenmoduls deklariert wird:<\/p>\n Die Schaltfläche zum Auslösen des Filters landet per Verweis in dieser Variablen:<\/p>\n Die Variable ist mit dem Schlüsselwort WithEvents <\/b>deklariert, was dafür sorgt, dass wir in diesem Klassenmodul Ereignisprozeduren für das Steuerelement implementieren können. Desweiteren benötigen wir noch zwei weitere Variablen. Die erste ist eine Collection und nimmt die Instanzen der Wrapper-Klassen auf, von denen wir für jedes filterbare Steuerelement eine erstellen und in die Collection schreiben:<\/p>\n Außerdem brauchen wir noch die besagte Variable, welche das zuletzt durch den Benutzer angeklickte Steuerelement im Unterformular aufnimmt:<\/p>\n Damit die Wrapper-Objekte, die jeweils eines der gebundenen Steuerelemente im Unterformular aufnehmen, einen Verweis auf das zuletzt durch den Benutzer angeklickte Element in die Variable m_CurrentControl <\/b>schreiben können, stellen wir eine Property Set<\/b>-Methode in der Klasse clsFastFilter <\/b>bereit, die wie folgt aussieht:<\/p>\n Damit wir die Funktion, welche die Schaltfläche cmdFastFilter <\/b>auslöst, auch in der Klasse clsFastFilter <\/b>unterbringen können und diese nicht in jedem neuen Formular erneut schreiben müssen, füllen wir die lokale Variable m_FastFilterButton <\/b>über die Property Set<\/b>-Prozedur FastFilterButton <\/b>mit einem Verweis auf die jeweilige Schaltfläche. Die Prozedur sieht so aus:<\/p>\n Sie erwartet einen Verweis auf die Schaltfläche als Parameter und trägt diese in die Variable m_FastFilterButton <\/b>ein. Außerdem legt sie noch fest, dass in diesem Klassenmodul eine Implementierung des Ereignisses OnClick <\/b>vorliegen könnte und beim Auslösen entsprechend berücksichtigt werden soll.<\/p>\n Die Hauptarbeit in der Klasse übernimmt die Property Set<\/b>-Methode Subform<\/b>, mit welcher die Form_Load<\/b>-Ereignisprozedur der Klasse clsFastFilter <\/b>das zu verwendende Unterformular zuweist. Sie erwartet das Formular als Parameter und sieht wie folgt aus:<\/p>\n Die Prozedur stellt zunächst die Variable m_Subform <\/b>auf das übergebene Formular ein. Dann instanziert sie eine neue Collection und speichert diese in der Variablen colControls<\/b>. Schließlich durchläuft sie alle Steuerelemente des mit frm <\/b>angegebenen Unterformulars. In der dafür verwendeten For Each<\/b>-Schleife prüft die Prozedur, ob es sich beim aktuell durchlaufenen Steuerelement überhaupt um ein gebundenes Steuerelement handelt. Andere Steuerelemente wie etwa Bezeichnungsfelder brauchen wir gar nicht zu berücksichtigen. Dazu leert die Prozedur eine Variable namens strControlSource <\/b>und versucht dann, diese bei deaktivierter Fehlerbehandlung mit dem Wert der Eigenschaft ControlSource <\/b>des aktuellen Steuerelements aus ctl <\/b>zu füllen. Enthält strControlSource <\/b>danach keine leere Zeichenkette, handelt es sich um ein gebundenes Steuerelement und es kann in Form des Wrapper-Objekts auf Basis der Klasse clsFastFilterControl <\/b>referenziert und zur Collection colControls <\/b>hinzugefügt werden. Dann erstellt die Prozedur ein neues Objekt auf Basis von clsFastFilterControl<\/b>, füllt dessen Eigenschaft Control <\/b>mit einem Verweis auf das aktuelle Steuerelement und die Eigenschaft MyParent <\/b>mit einem Verweis auf sich selbst, also die Instanz der Klasse clsFastFilter<\/b>. Wozu dies nötig ist, erfahren Sie gleich bei der Beschreibung der Klasse clsFastFilterControl<\/b>. Nun müssen wir nur noch dafür sorgen, dass das Wrapper-Objekt, das ja lokal innerhalb der Property Set<\/b>-Prozedur deklariert wurde und anderenfalls mit dem Ende der Prozedur erlöschen würde, nicht im Nirwana verschwindet. Dazu fügt die Prozedur es zur Collection colControls <\/b>hinzu.<\/p>\n Gehen wir an dieser Stelle vereinfachend davon aus, dass die Wrapper-Objekte beim Anklicken durch den Benutzer dafür sorgen, dass ein Verweis auf das angeklickte gebundene Steuerelement in der Variablen m_CurrentControl <\/b>landet.<\/p>\n Dann können wir uns die Ereignisprozedur ansehen, die durch einen Mausklick auf die mit der Variablen m_FastFilterButton<\/b> referenzierte Schaltfläche ausgelöst wird. Die Prozedur sieht wie in Listing 1 aus. Sie liest zunächst den Namen des Feldes, das dem mit der Variablen m_CurrentControl <\/b>referenzierten und zuletzt durch den Benutzer angeklickten Steuerelement angehört, in die Variable strControlSource <\/b>ein.<\/p>\n Listing 1: Implementierung des Beim Klicken-Ereignisses der Filter-Schaltfläche<\/span><\/b><\/p>\n Dann füllt sie eine Recordset<\/b>-Variable namens rst <\/b>mit dem Recordset des zu filternden Unterformulars. Sie ermittelt dann für das Element der Fields<\/b>-Auflistung mit dem Namen aus strControlsource <\/b>den Datentyp und gleicht diesen in einer Select Case<\/b>-Bedingung mit verschiedenen Werten ab. Wir haben hier nur dbText <\/b>für Textfelder, dbDate <\/b>für Datumsfelder und alle übrigen Datentypen untersucht, obwohl hier noch weitere Unterscheidungen möglich wären. Im Falle des Wertes dbText <\/b>stellt die folgende Anweisung einen Vergleichsausdruck zusammen, der aus dem Feldnamen aus strControlSource<\/b>, dem Gleichheitszeichen und dem in Hochkommata eingefassten Wert des Steuerelements aus m_CurrentControl <\/b>besteht, also etwa Artikelname = “Chai“<\/b>. Dieser Vergleichsausdruck landet in der Eigenschaft Filter <\/b>des Unterformulars. Das Einstellen einer weiteren Eigenschaft namens FilterOn <\/b>auf den Wert True <\/b>sorgt schließlich dafür, dass der Filter auch auf die aktuellen Daten angewendet wird.<\/p>\n <\/p>\n Wichtig ist an dieser Stelle noch der Hinweis auf das eventuelle Auftreten von Hochkommata oder Anführungszeichen innerhalb der Zeichenkette. Diese führen beim Zusammensetzen des Filterausdrucks zu Fehlern, was nicht geschieht, wenn Sie diese verdoppeln – in diesem Fall durch entsprechenden Einsatz der Replace<\/b>-Funktion.<\/p>\n Im Falle eines Datums würde, wenn wir dieses einfach wie eine Zahl behandeln, ein Ausdruck wie Auslaufdatum = 1.1.2016 <\/b>verwendet, was zu einem Fehler führt. Daher wandeln wir den Wert des Datumsfeldes zuvor mit der CDbl<\/b>-Funktion in einen Double<\/b>-Wert um, der dann keinen Fehler mehr auslöst.<\/p>\n Für alle übrigen Datentypen soll einfach das Feld mit dem jeweiligen Wert verglichen werden.<\/p>\n Es fehlt noch ein genauerer Blick auf die Klasse clsFastFilterControl<\/b>. Diese wird für jedes gebundene Steuerelement im Unterformular genau einmal instanziert, denn wir wollen ja für jedes dieser Steuerelemente das Ereignis Bei Fokuserhalt <\/b>implementieren, um dort das aktuelle Steuer-element in der Variablen m_CurrentControl <\/b>des Objekts basierend auf der Klasse clsFastFilter <\/b>zu speichern.<\/p>\n Die Klasse clsFastFilterControl <\/b>soll zunächst einmal einen Verweis auf das erstellende Objekt speichern, hier also das Objekt auf Basis der Klasse clsFastFilter<\/b>. Dazu verwenden wir die folgende Variable:<\/p>\n Die benötigte Property Set<\/b>-Methode sieht so aus:<\/p>\n Außerdem wollen wir bei den Steuerelementen des Datenblatts unter den Steuerelementtypen Textfeld, Kombinationsfeld und Kontrollkästchen unterscheiden (andere Steuerelemente machen im Datenblatt auch keinen Sinn). Daher deklarieren wir die folgenden drei Variablen innerhalb der Klasse, da wir ja noch nicht wissen, welchen Steuerelementtyp die Klasse aufnehmen soll:<\/p>\n Nun fehlt noch die Property Set<\/b>-Methode, die das zu untersuchende Steuerelement entgegennimmt und einige weitere Schritte durchführt. Diese sieht wie folgt aus:<\/p>\n Die Prozedur prüft zunächst anhand der Eigenschaft ControlType<\/b>, um welchen Typ es sich handelt. Im Falle von acTextBox <\/b>füllt sie beispielsweise die Variable txt <\/b>mit einem Verweis auf das mit dem Parameter ctl <\/b>gelieferte Steuerelement. Außerdem stellt sie die Eigenschaft OnGotFocus <\/b>auf den Wert [Event Procedure] <\/b>ein, was im Eigenschaftsfenster des Formulars dem Einstellen der Eigenschaft Bei Fokuserhalt <\/b>auf [Ereignisprozedur] <\/b>entspricht. Für die beiden anderen Typen, die mit den Konstanten dbComboBox <\/b>und dbCheckBox <\/b>geprüft werden, verläuft dies ähnlich. Schließlich müssen wir noch das Ereignis Bei Fokuserhalt <\/b>für die drei deklarierten Objektvariablen für die drei Steuerelementtypen Textfeld<\/b>, Kombinationsfeld <\/b>und Kontrollkästchen <\/b>implementieren, was wir wie folgt erledigen:<\/p>\n In diesen drei Prozeduren weisen wir jeweils der Eigenschaft CurrentControl <\/b>des in m_Parent <\/b>gespeicherten Objekts (also unsere Instanz der Klasse clsFastFilter<\/b>) eine Referenz auf das auslösende Steuerelement zu, die dann wiederum in der Variablen m_CurrentControl <\/b>der Klasse clsFastFilter <\/b>landet. Damit ist die Programmierung der grundlegenden Funktion bereits erledigt: Wir können das Datenblatt nun nach den Werten einzelner Felder filtern.<\/p>\n Für den Einsatz mit Textfeldern wäre es noch interessant, wenn wir auch Vergleiche mit Teilausdrücken erlauben würden. Wie wäre es etwa, wenn Sie nur ein paar Buchstaben des Feldinhalts eines Textfeldes markieren und danach in allen Datensätzen suchen wollten Das wäre schon praktisch, also machen wir uns an die Arbeit. Zu diesem Zweck fügen wir dem Formular eine weitere Schaltfläche namens cmdSchnellerFilterTeilausdruck <\/b>hinzu. Die Prozedur Form_Load<\/b> erweitern wir entsprechend um die Zuweisung dieser Schaltfläche zur gleich noch anzulegenden Eigenschaft in der Klasse clsFast-Filter<\/b>:<\/p>\n Die Klasse clsFastFilter <\/b>erhält eine neue Variable zum Speichern der Schaltfläche:<\/p>\n Um diese Schaltfläche der Variablen zuzuweisen, benötigen wir eine entsprechende Property Set-Prozedur:<\/p>\n Im gleichen Zuge fügen wir eine Variable hinzu, welche die Teilzeichenkette speichert:<\/p>\n Um diese einzustellen, legen wir eine öffentliche Eigenschaft per Property Let<\/b>-Prozedur fest:<\/p>\n Damit die Schaltfläche cmdSchnellerFilterTeilausdruck <\/b>auch etwas bewirkt, legen wir die Ereignisprozedur aus Listing 2 in der Klasse clsFastFilter <\/b>an. Diese berücksichtigt nur Steuerelemente, deren gebundenes Feld den Felddatentyp dbText <\/b>aufweist. Für diese stellt es einen Vergleichsausdruck zusammen, der aus dem Feldnamen, dem LIKE<\/b>-Operator sowie dem Vergleichswert besteht. Dieser stammt aus der Variablen m_Searchstring<\/b>, bei dem eventuell enthaltene Hochkommata verdoppelt wurden. Der Vergleichswert wird außerdem in Sternchen und einfache Anführungszeichen eingeschlossen. Wenn der Benutzer nun etwa die Zeichenkette an <\/b>des Artikels Chang <\/b>markiert und auf die Schaltfläche klickt, soll der Filterausdruck so aussehen:<\/p>\n![\"Filtern](\"..\/fileadmin\/_temp_\/2017_01\/pic_1072_002.png\")
<\/p>\nDatensätze mit gleichem Feldwert finden<\/h2>\n
![\"So](\"..\/fileadmin\/_temp_\/2017_01\/pic_1072_004.png\")
<\/p>\nSchaltfläche zum schnellen Filtern<\/h2>\n
Private Sub <\/span>cmdSchnellerFilter_Click()\r\n Debug.Print<\/span> Screen.PreviousControl.Name\r\nEnd Sub<\/span><\/pre>\nsfmArtikel_SchnellerFilter<\/pre>\n
Zuletzt aktives Feld ermitteln<\/h2>\n
Lösung mit Klasse<\/h2>\n
Dim <\/span>objFastFilter As <\/span>clsFastFilter<\/pre>\nPrivate Sub <\/span>Form_Load()\r\n Set<\/span> objFastFilter = New<\/span> clsFastFilter\r\n With<\/span> objFastFilter\r\n Set<\/span> .Subform = Me!sfmArtikel_SchnellerFilter.Form\r\n Set<\/span> .FastFilterButton = Me!cmdSchnellerFilter\r\n End With<\/span>\r\nEnd Sub<\/span><\/pre>\nPrivate Sub <\/span>cmdFilterLeeren_Click()\r\n Me!sfmArtikel_SchnellerFilter.Form.Filter = \"\"\r\nEnd Sub<\/span><\/pre>\nWichtige Vorbereitung<\/h2>\n
![\"Hinzufügen](\"..\/fileadmin\/_temp_\/2017_01\/pic_1072_003.png\")
<\/p>\nDie Klasse clsFastFilter<\/h2>\n
Private <\/span>m_Subform As <\/span>Form<\/pre>\nPrivate <\/span>WithEvents m_FastFilterButton As <\/span>CommandButton<\/pre>\nPrivate <\/span>colControls As <\/span>Collection<\/pre>\nPrivate <\/span>m_CurrentControl As <\/span>Control<\/pre>\nPublic Property Set<\/span> <\/span>CurrentControl(ctl As <\/span>Control)\r\n Set<\/span> m_CurrentControl = ctl\r\nEnd Property<\/span><\/pre>\nPublic Property Set<\/span> <\/span>FastFilterButton(cmd As <\/span>CommandButton)\r\n Set<\/span> m_FastFilterButton = cmd\r\n cmd.OnClick = \"[Event Procedure]\"\r\nEnd Property<\/span><\/pre>\nPublic Property Set<\/span> <\/span>Subform(frm As <\/span>Form)\r\n Dim <\/span>ctl As <\/span>Control\r\n Dim <\/span>objFastFilterControl As <\/span>clsFastFilterControl\r\n Dim <\/span>strControlSource As String<\/span>\r\n Set<\/span> m_Subform = frm\r\n Set<\/span> colControls = New<\/span> Collection\r\n For Each ctl In m_Subform.Controls\r\n strControlSource = \"\"\r\n On Error Resume Next<\/span>\r\n strControlSource = ctl.ControlSource\r\n On Error GoTo<\/span> 0\r\n If <\/span>Len<\/span>(strControlSource) > 0 Then<\/span>\r\n Set<\/span> objFastFilterControl = New<\/span> clsFastFilterControl\r\n With<\/span> objFastFilterControl\r\n Set<\/span> .Control = ctl\r\n Set<\/span> .MyParent = Me\r\n colControls.Add objFastFilterControl\r\n End With<\/span>\r\n End If<\/span>\r\n Next<\/span> ctl\r\nEnd Property<\/span><\/pre>\nPrivate Sub <\/span>m_FastFilterButton_Click()\r\n Dim <\/span>rst As <\/span>DAO.Recordset\r\n Dim <\/span>fld As <\/span>DAO.Field\r\n Dim <\/span>strControlSource As String<\/span>\r\n strControlSource = m_CurrentControl.ControlSource\r\n Set<\/span> rst = m_Subform.Recordset\r\n Select Case rst.Fields(strControlSource).Type\r\n Case <\/span>dbText\r\n m_Subform.Filter = strControlSource & \" = ''\" _\r\n & Replace<\/span>(m_CurrentControl.Value, \"''\", \"''''\") & \"''\"\r\n m_Subform.FilterOn = True<\/span>\r\n Case <\/span>dbDate\r\n m_Subform.Filter = strControlSource & \" = \" & CDbl(m_CurrentControl.Value)\r\n m_Subform.FilterOn = True<\/span>\r\n Case Else<\/span>\r\n m_Subform.Filter = strControlSource & \" = \" & m_CurrentControl.Value\r\n m_Subform.FilterOn = True<\/span>\r\n End Select<\/span>\r\nEnd Sub<\/span><\/pre>\nDie Klasse clsFastFilterControl<\/h2>\n
Private <\/span>m_Parent As <\/span>clsFastFilter<\/pre>\nPublic Property Set<\/span> <\/span>MyParent(obj As <\/span>clsFastFilter)\r\n Set<\/span> m_Parent = obj\r\nEnd Property<\/span><\/pre>\nPrivate <\/span>WithEvents txt As <\/span>TextBox\r\nPrivate <\/span>WithEvents cbo As <\/span>ComboBox\r\nPrivate <\/span>WithEvents chk As <\/span>CheckBox<\/pre>\nPublic Property Set<\/span> <\/span>Control(ctl As <\/span>Control)\r\n Select Case ctl.ControlType\r\n Case <\/span>acTextBox\r\n Set<\/span> txt = ctl\r\n txt.OnGotFocus = \"[Event Procedure]\"\r\n Case <\/span>acComboBox\r\n Set<\/span> cbo = ctl\r\n cbo.OnGotFocus = \"[Event Procedure]\"\r\n Case <\/span>acCheckBox\r\n Set<\/span> chk = ctl\r\n chk.OnGotFocus = \"[Event Procedure]\"\r\n End Select<\/span>\r\nEnd Property<\/span><\/pre>\nPrivate Sub <\/span>cbo_GotFocus()\r\n Set<\/span> m_Parent.CurrentControl = cbo\r\nEnd Sub<\/span>\r\nPrivate Sub <\/span>chk_GotFocus()\r\n Set<\/span> m_Parent.CurrentControl = chk\r\nEnd Sub<\/span>\r\nPrivate Sub <\/span>txt_GotFocus()\r\n Set<\/span> m_Parent.CurrentControl = txt\r\nEnd Sub<\/span><\/pre>\nFiltern nach „Enthält …“<\/h2>\n
Private Sub <\/span>Form_Load()\r\n Set<\/span> objFastFilter = New<\/span> clsFastFilter\r\n With<\/span> objFastFilter\r\n ...\r\n Set<\/span> .FastFilterContainsButton = Me!cmdSchnellerFilterTeilausdruck\r\n End With<\/span>\r\nEnd Sub<\/span><\/pre>\nPrivate <\/span>WithEvents m_FastFilterContainsButton As <\/span>CommandButton<\/pre>\nPublic Property Set<\/span> <\/span>FastFilterContainsButton( cmd As <\/span>CommandButton)\r\n Set<\/span> m_FastFilterContainsButton = cmd\r\n With<\/span> cmd\r\n .OnClick = \"[Event Procedure]\"\r\n End With<\/span>\r\nEnd Property<\/span><\/pre>\nPrivate <\/span>m_Searchstring As String<\/span><\/pre>\nPublic Property Let <\/span>Searchstring(str As String<\/span>)\r\n m_Searchstring = str\r\nEnd Property<\/span><\/pre>\nPrivate Sub <\/span>m_FastFilterContainsButton_Click()\r\n Dim <\/span>rst As <\/span>DAO.Recordset\r\n Dim <\/span>strControlSource As String<\/span>\r\n strControlSource = m_CurrentControl.ControlSource\r\n Set<\/span> rst = m_Subform.Recordset\r\n Select Case rst.Fields(strControlSource).Type\r\n Case <\/span>dbText\r\n m_Subform.Filter = strControlSource & \" LIKE ''*\" & Replace<\/span>(m_Searchstring, \"''\", \"''''\") & \"*''\"\r\n m_Subform.FilterOn =