<\/p>\n
Wenn man Daten aus einer Liste nach verschiedenen Kriterien filtern möchte, kann man gar nicht genug Komfort haben. In diesem Beitrag stellen wir Ihnen eine Lösung vor, mit der Sie in einem Unterformular in der Datenblattansicht suchen können – und zwar mit allen Finessen. Das heißt, dass Sie entweder zuerst alle Suchparameter eingeben und dann die Suche anstoßen können oder auch gleich mit Eingabe eines jeden Zeichens ein aktualisiertes Suchergebnis erhalten. Oder dass Sie entscheiden können, ob die Daten nur nach genauen Treffern durchsucht werden sollen.<\/b><\/p>\n
Es gibt verschiedene Ansätze, wie sich Suchfunktionen in Datenbankanwendungen implementieren lassen. Einige finden direkt in dem Formular Platz, das auch die zu durchsuchenden Daten anzeigt, andere erscheinen als eigenes Formular, das auch gleich die Suchergebnisse präsentiert. In unserem Fall soll die Übersichtsliste der zu durchsuchenden Daten in einem Formular und das Suchformular als Popup-Formular erscheinen. Auf diese Weise können Sie das Formular mit den Suchkriterien an beliebiger Stelle platzieren, die Suchbegriffe eingeben, ändern oder entfernen und zu jeder Zeit das Suchergebnis aktualisieren lassen. Im Detail sieht das wie in Bild 1 aus.<\/p>\n
![\"pic001.png\"](\"..\/fileadmin\/_temp_\/2012_05\/KundensucheMitKomfort-web-images\/pic001.png\")
<\/p>\n
Bild 1: Suchformular und zu durchsuchende Daten im Überblick<\/span><\/b><\/p>\n Funktionen des Suchformulars<\/b><\/p>\n Der Benutzer soll beliebige Suchbegriffe in die Suchfelder eingeben können. Kombinationsfelder dienen zur direkten Auswahl von Suchbegriffen – im Beispiel etwa die Anrede, für die es nur zwei Möglichkeiten gibt. Bei der Eingabe der Suchbegriffe kann der Benutzer entweder erst alle gewünschten Suchbegriffe in die Textfelder eingeben beziehungsweise aus den Kombinationsfeldern auswählen und dann die Suche mit einem Klick auf die Schaltfläche Suchen <\/b>starten. Oder er aktiviert die Option Schnellsuche <\/b>oben im Formularkopf: Dann führt die Eingabe eines jeden Zeichens und die Auswahl eines jeden Kombinationsfeldeintrags zur Anzeige der gefundenen Einträge in der zu durchsuchenden Liste.<\/p>\n Eine weitere Option legt fest, ob die Textfelder nur nach genauen Treffern durchsucht werden sollen (Andre <\/b>zeigt dann nur Datensätze mit Andre<\/b>, aber keine mit Andreas <\/b>an), ob auch Treffer ausgegeben werden sollen, die mit dem eingegebenen Suchbegriff beginnen oder ob das Suchergebnis sogar solche Treffer liefern soll, bei denen der Suchbegriff irgendwo im Text enthalten ist (An <\/b>liefert dann sowohl Andre <\/b>als auch Hermann<\/b>).<\/p>\n Die Schaltfläche Leeren <\/b>soll alle Suchbegriffe wieder auf den Anfangszustand zurücksetzen, die Schaltfläche Abbrechen<\/b> schließt den Dialog.<\/p>\n Aufruf des Suchformulars<\/b><\/p>\n Das Formular mit dem zu durchsuchenden Datenblatt wird mit einer Schaltfläche namens cmdSuchen <\/b>ausgestattet, die folgende Ereignisprozedur auslöst:<\/p>\n Dies öffnet das Formular namens frmKundensuche <\/b>und übergibt den Namen des zu durchsuchenden Unterformulars als Öffnungsargument. Die Programmierung der hier verwenden Kundenübersicht finden Sie im Beitrag Programmierung der KVA <\/b>(www.access-im-unternehmen.de\/857<\/b>).<\/p>\n Anlegen des Suchformulars<\/b><\/p>\n Das Suchformular sieht im Entwurf wie in Bild 2 aus. Es enthält alle Felder, die Sie auch im Unterformular mit den zu durchsuchenden Daten finden, nämlich die Felder der Tabelle tblKundenBase<\/b> der Beispielanwendung KVA.mdb<\/b>.<\/p>\n Bild 2: Entwurf des Suchformulars<\/span><\/b><\/p>\n Die Suchfelder sollen Namen erhalten, die aus dem Feldnamen und einem Präfix bestehen – txt <\/b>für Textfelder und cbo <\/b>für Kombinationsfelder. Die Bezeichnungsfelder weisen auf den Inhalt des jeweils zu durchsuchenden Feldes hin. Wenn Sie die Felder nicht alle von Hand anlegen möchten, können Sie dies mit einem kleinen Trick erledigen. Stellen Sie dazu die Datenherkunft eines leeren Formulars auf die Tabelle ein, welche die zu durchsuchenden Daten enthält – hier tblKundenBase<\/b> – und ziehen Sie alle benötigten Felder aus der Feldliste in den Detailbereich des Formulars (s. Bild 3).<\/p>\n Bild 3: Anlegen der Suchfelder<\/span><\/b><\/p>\n Danach passen Sie, sofern die Eigenschaft Beschriftung <\/b>der Felder im Tabellenentwurf nicht bereits mit entsprechenden Beschriftungen versehen war, die Beschriftungsfelder an (zum Beispiel von EMail <\/b>zu E-Mail<\/b>).<\/p>\n Nun versehen Sie die Eigenschaftsnamen noch mit entsprechenden Präfixen, also txt <\/b>für die Textfelder und cbo <\/b>für die als Nachschlagefelder ausgelegten Suchfelder. Sie können das manuell erledigen oder Sie nutzen das Add-In Control Renamer<\/b>, das im Beitrag Access-Add-Ins <\/b>(www.access-im-unternehmen.de\/643<\/b>) vorgestellt wird. Damit können Sie die Steuerelemente mit einem Mausklick um das gewünschte Präfix erweitern. Achtung: Dies gelingt nur, solange die Steuerelemente noch gebunden sind – erledigen Sie dies also vor dem folgenden Schritt, wenn Sie den Control Renamer <\/b>einsetzen möchten.<\/p>\n Nun benötigen wir allerdings keine gebundenen Felder, sondern nur einfache Textfelder. Glücklicherweise können Sie Eigenschaften immer für mehrere Steuerelemente gleichzeitig ändern. Also markieren Sie durch Aufziehen eines entsprechenden Rahmens alle Textfelder und kümmern sich um die Eigenschaft Steuerelementinhalt<\/b>. Diese wird bereits als leer angezeigt, aber nur, weil die Eigenschaft für alle markierten Steuerelemente unterschiedliche Werte aufweist. Wie aber leeren wir eine bereits als leer dargestellte Eigenschaft Ganz einfach: Sie tippen ein beliebiges Zeichen in die Eigenschaft, was alle vorhandenen Werte überschreibt, und löschen dieses wieder. Nun ist die Eigenschaft Steuerelement <\/b>tatsächlich leer, wie die Kontrolle der Eigenschaft für ein einzelnes Steuerelement belegt.<\/p>\n Anpassen der Kombinationsfelder<\/b><\/p>\n Die Kombinationsfelder cboAnredeID <\/b>und cboPersoenlicheAnredeID <\/b>bieten, wenn Sie die entsprechenden Felder der Tabelle tblKundenBase <\/b>als Nachschlagefelder eingerichtet haben, alle Datensätze der zugrunde liegenden Tabellen zur Auswahl an. Um den Komfort der Suchfunktion zu erhöhen, sollen diese gleich beim Anzeigen des Suchformulars Einträge wie <Alle> <\/b>anzeigen. Dazu passen wir die Datensatzherkunft der beiden Steuerelemente etwas an. Für das Steuerelement cboAnredeID <\/b>hinterlegen Sie hier den folgenden Ausdruck:<\/p>\n Der Ausdruck für die Eigenschaft Datensatzherkunft <\/b>des Steuerelements cboPersoenlicheAnredeID <\/b>ist ähnlich aufgebaut:<\/p>\n Weitere Steuerelemente<\/b><\/p>\n Fügen Sie dem Formular nun die übrigen Steuerelemente hinzu:<\/p>\n Programmierung der Suchfunktion<\/b><\/p>\n Bei den folgenden Ausführungen ist es wichtig zu wissen, dass das Suchformular dafür konzipiert ist, von einem anderen Formular per Schaltfläche geöffnet zu werden. Außerdem muss dieses Formular das Unterformular in der Datenblattansicht enthalten, dessen Datensätze mithilfe des Suchformulars gefiltert werden sollen.<\/p>\n Es gibt also eine Interaktion zwischen dem aufrufenden Formular sowie dem aufgerufenen Suchformular – nicht nur in einer Richtung:<\/p>\n Für diese Interaktion benötigt das Suchformular einen Verweis auf das Hauptformular. Diesen speichert das Suchformular in einer Variablen namens frmParent<\/b>. Damit das Suchformular auf das Schließen des zu durchsuchenden Formulars reagieren kann, wird diese Objektvariable mit dem Schlüsselwort WithEvents <\/b>deklariert:<\/p>\n Um das im aufrufenden Formular enthaltene Unterformular in der Datenblattansicht aktualisieren beziehungsweise filtern zu können, benötigen wir auch einen Verweis auf dieses Element.<\/p>\n Dieses speichern wir in der folgenden Variable – WithEvents <\/b>ist hier nicht nötig, da wir nicht auf Ereignisse im Unterformular reagieren müssen:<\/p>\n Damit kommen wir zu der Prozedur, die durch das Ereignis Beim Öffnen <\/b>des Formulars ausgelöst wird und wie in Listing 1<\/a><\/span> aussieht.<\/p>\n Listing 1: Die Prozedur, die durch das Ereignis Beim Öffnen ausgeführt wird<\/p>\n Die Prozedur hat zunächst die Aufgabe, das Formular sofort mit einer entsprechenden Meldung wieder zu schließen, wenn dieses über einen anderen Weg als über die dafür vorgesehene Schaltfläche geöffnet wird. Dazu prüft die Prozedur zunächst, ob beim Aufruf des Formulars mit der DoCmd.OpenForm<\/b>-Methode ein Öffnungsargument übergeben wurde.<\/p>\n Ist dies der Fall, holt sich die Prozedur zunächst einen Verweis auf das Steuerelement, das beim Aufrufen des Formulars aktiv ist – in diesem Fall also die Schaltfläche cmdSuchen <\/b>des zu durchsuchenden Formulars.<\/p>\n Dieses Steuerelement wiederum hat eine Parent<\/b>-Eigenschaft, die auf das Form<\/b>-Objekt verweist, in dem sich die Schaltfläche befindet. Ein Verweis auf dieses Formular landet in der bereits erwähnten Variablen objParent<\/b>.<\/p>\n <\/p>\n Das mit Me.OpenArgs <\/b>abgefragte Öffnungsargument liefert den Namen des zu durchsuchenden Unterformulars, zu dem sich die Prozedur mit frmParent(Me.OpenArgs).Form <\/b>ebenfalls einen Verweis holt und diesen diesmal in der Variablen frmDataSheet <\/b>speichert.<\/p>\n Für das in frmParent <\/b>gespeicherte Formular soll eine Ereignisprozedur im Klassenmodul des Formulars frmKundensuche <\/b>implementiert werden, das durch das Ereignis Beim Entladen<\/b> ausgelöst wird. Dies gibt die Prozedur Form_Open <\/b>mit der folgenden Zeile zunächst bekannt:<\/p>\n Die Implementierung der Ereignisprozedur sieht schließlich so aus:<\/p>\n Damit haben wir zwar noch keine Suchfunktion programmiert, aber zumindest ist sichergestellt, dass das Suchformular zusammen mit dem aufrufenden Formular auch wieder geschlossen wird. Dies könnte nämlich wiederum zu Problemen führen, wenn der Benutzer das Suchformular noch einsetzt, obwohl das zu durchsuchende Formular längst geschlossen ist.<\/p>\n Kommen wir nun zur Ereignisprozedur, die durch das Ereignis Beim Laden <\/b>des Steuerelements ausgelöst wird.<\/p>\n Dies sieht wie in Listing 2<\/a><\/span> aus und enthält für den aktuellen Zeitpunkt nur zwei wichtige Anweisungen – nämlich diejenigen, welche die Werte der beiden Kombinationsfelder cboAnredeID <\/b>und cboPersoenlicheAnredeID <\/b>auf den jeweils ersten Eintrag einstellen – also auf <Alle><\/b>. Auf die übrigen Anweisungen kommen wir im späteren Verlauf zurück.<\/p>\n Listing 2: Die Prozedur, die durch das Ereignis Beim Laden ausgeführt wird<\/p>\n Aufrufen der Suchfunktion<\/b><\/p>\n Das Programmieren der Suchfunktion wäre einfach, wenn diese nur über die Schaltfläche cmdSuchen <\/b>gestartet werden könnte (beziehungsweise das Betätigen der Eingabe-Taste – durch Einstellen der Eigenschaft Standard <\/b>der Schaltfläche cmdSuchen <\/b>auf den Wert Ja <\/b>löst auch die Eingabe-Taste die Ereignisprozedur cmdSuchen_Click <\/b>aus).<\/p>\n Aber um die Suche noch etwas komfortabler zu gestalten, haben wir entschieden, dass der Benutzer durch Aktivieren der Option Schnellsuche <\/b>dafür sorgen kann, dass die Suche nach der Eingabe eines jeden Zeichens in eines der Textfelder beziehungsweise der Auswahl eines Eintrags der Kombinationsfelder erneut durchgeführt werden soll.<\/p>\n Damit ergeben sich kleinere Probleme: Wenn Sie nämlich beispielsweise einen Buchstaben in das Textfeld txtVorname <\/b>eingeben, soll der Filter entsprechend zusammengestellt werden (etwa Vorname LIKE “A“<\/b>). Dazu muss die Prozedur, die den Filterausdruck zusammenstellt, den im Suchfeld angegebenen Text einlesen. Dies gelingt, ohne die Eingabe in das Textfeld abzuschließen, nur über die Text<\/b>-Eigenschaft des Textfeldes. Bei Feldern, die gerade nicht bearbeitet werden, reicht das Abfragen der Value<\/b>-Eigenschaft aus.<\/p>\n In der Schleife, die alle Steuerelemente durchläuft, um den Filterausdruck zusammenzustellen, müssten wir also auch noch prüfen, ob das aktuell durchlaufene Steuerelement eventuell gerade in Bearbeitung ist, und dementsprechend entweder auf die Value<\/b>– oder die Text<\/b>-Eigenschaft zugreifen, um den aktuellen Inhalt des Steuerelements zu ermitteln.<\/p>\n Da dies sehr unpraktisch ist, sorgen wir dafür, dass der Inhalt der Textfelder nach jeder änderung in der sonst nicht verwendeten Eigenschaft Tag <\/b>gespeichert wird. Dazu müssten wir nun für jedes Textfeld eine Ereignisprozedur anlegen, die beispielsweise wie folgt aussieht:<\/p>\n Die Prozedur trägt den aktuellen Text des Textfeldes (nicht zu verwechseln mit dem Wert) in die Eigenschaft Tag <\/b>ein. Außerdem prüft sie, ob die Option chkSchnellsuche <\/b>aktiviert ist, und ruft gleich noch die Prozedur Suchen <\/b>auf, um das Suchergebnis zu aktualisieren (mehr zu dieser Prozedur weiter unten).<\/p>\n Nun macht es erstens keinen Spaß, für jedes Steuerelement eine solche Prozedur anzulegen, und zweitens müssen Sie dies für eventuell hinzukommende Steuerelemente auch noch jedesmal wiederholen. Also programmieren wir eine kleine Klasse namens clsSuchformularControl<\/b>, die jeweils den Verweis auf eines der Steuerelemente speichert und auch noch die oben beschriebene Ereignisprozedur enthält, die den Suchbegriff zwischenspeichert und die Suchfunktion aufruft.<\/p>\n Der komplette Code dieser Klasse sieht wie in Listing 3<\/a><\/span> aus. Die Funktion dieser Klasse schauen wir uns in Zusammenhang mit den Anweisungen der Prozedur an, die beim Laden des Formulars ausgelöst wird und die wir weiter oben noch nicht besprochen haben.<\/p>\n Listing 3: Inhalt des Klassenmoduls clsSuchformularControl<\/p>\n Eine wichtige Rolle spielt dabei das wie folgt im Kopf des Klassenmoduls Form_frmSuchformular <\/b>deklarierte Collection<\/b>-Objekt, das alle Instanzen der Klasse clsSuchformularControl <\/b>aufnehmen soll:<\/p>\n Dieses Collection<\/b>-Objekt wird in der Prozedur Form_Load <\/b>zunächst instanziert:<\/p>\n Danach durchläuft diese Prozedur eine For Each<\/b>-Schleife über alle Steuerelemente des Suchformulars, wobei sie zunächst anhand der Eigenschaft ControlType <\/b>prüft, ob es sich um ein Textfeld oder ein Kombinationsfeld handelt. In diesem Fall erstellt die Prozedur für das Steuerelement eine neue Instanz der Klasse clsSuchformularControl<\/b>. Diese bietet eine Eigenschaft namens SearchControl <\/b>an, der die Prozedur einen Verweis auf das aktuelle mit ctl <\/b>referenzierte Steuerelement übergibt. Anschließend wird der Verweis auf die neu erzeugte Instanz objSuchformularControl <\/b>in der Collection colSuchformularSteuerelemente <\/b>gespeichert.<\/p>\n Nun schauen wir uns an, was in dieser Zeit in der Klasse clsSuchformularControl <\/b>geschieht. Beim Erzeugen der Klasse geschieht noch nichts, aber das Zuweisen eines Steuerelements an die Eigenschaft SearchControl <\/b>löst die Property Set<\/b>-Prozedur SearchControl <\/b>aus. Diese nimmt den Verweis auf das Steuerelement entgegen und speichert es zunächst in der Objektvariablen m_ctl<\/b>.<\/p>\n Dann prüft sie, ob es sich bei dem mit m_ctl <\/b>referenzierten Steuerelement um ein Textfeld oder ein Kombinationsfeld handelt, und fährt mit dem entsprechenden Zweig einer Select Case<\/b>-Anweisung fort. Handelt es sich um ein Textfeld, wird der Verweis auf das Steuerelement an die Variable m_txt <\/b>weitergereicht, die im Kopf des Klassenmoduls mit dem Schlüsselwort WithEvents <\/b>deklariert wurde:<\/p>\n Die Prozedur gibt durch Zuweisen des Wertes [Event Procedure] <\/b>für die Eigenschaft OnChange <\/b>der Variablen m_txt <\/b>an, dass es in der gleichen Klasse noch eine Ereignisprozedur geben könnte, die gegebenenfalls ausgelöst werden soll. Dabei handelt es sich um das Bei änderung<\/b>-Ereignis, das bei jeder Eingabe eines Zeichens ausgelöst wird.<\/p>\n In diesem Fall soll die folgende Prozedur aufgerufen werden, die erstens den aktuellen Text im Textfeld in der Eigenschaft Tag<\/b> speichert und zweitens die Suchfunktion auslöst, falls die Option chkSchnellsuche <\/b>im Formular des Textfeldes aktiviert ist:<\/p>\n Gleiches geschieht, wenn die Prozedur SearchControl <\/b>in der For Each<\/b>-Schleife auf ein Kombinationsfeld stößt. Hier wird allerdings nicht der aktuelle Wert zwischengespeichert, denn in Kombinationsfeldern ist die Eingabe ja mit der Auswahl eines der Einträge bereits abgeschlossen. Allerdings soll auch hier automatisch die Suche durchgeführt werden, wenn das Ereignis Nach Aktualisierung <\/b>ausgelöst wird und die Option chkSchnellsuche <\/b>aktiviert ist:<\/p>\n Suchfunktion programmieren<\/b><\/p>\n Nun können wir uns endlich der eigentlichen Suchfunktion zuwenden.<\/p>\n Diese heißt Suchen <\/b>und wird im einfachsten Fall durch einen Mausklick auf die Schaltfläche cmdSuchen <\/b>ausgelöst:<\/p>\n Dies geschieht, nachdem für diese Schaltfläche die Eigenschaft Standard <\/b>auf Ja <\/b>eingestellt ist, auch beim Betätigen der Eingabe-Taste innerhalb des Suchformulars.<\/p>\n Die Prozedur Suchen <\/b>sieht wie folgt aus:<\/p>\n Sie ruft zunächst die Funktion SuchfilterErstellen <\/b>auf und speichert das Ergebnis in der Variablen strSuchfilter<\/b>. Eine If…Then<\/b>-Bedingung prüft, ob die Variable strSuchfilter <\/b>leer ist. Ist das der Fall, wird der Eigenschaft Filter <\/b>des mit frmDatasheet <\/b>referenzierten Unterformulars eine leere Zeichenkette zugewiesen und die Eigenschaft FilterOn<\/b> auf False <\/b>eingestellt. Anderenfalls weist die Prozedur der Eigenschaft Filter <\/b>den ermittelten Filterausdruck zu, der beispielsweise wie folgt aussehen kann:<\/p>\nPrivate Sub cmdSuche_Click()\r\n DoCmd.OpenForm "frmKundensuche", OpenArgs:="sfmKundenuebersicht"\r\nEnd Sub<\/pre>\n
![\"pic012.png\"](\"..\/fileadmin\/_temp_\/2012_05\/KundensucheMitKomfort-web-images\/pic012.png\")
<\/p>\n![\"pic002.png\"](\"..\/fileadmin\/_temp_\/2012_05\/KundensucheMitKomfort-web-images\/pic002.png\")
<\/p>\nSELECT 0 AS AnredeID, ''<Alle>'' AS Anrede\r\nFROM tblAnreden\r\nUNION\r\nSELECT AnredeID, Anrede FROM tblAnreden;<\/pre>\n
SELECT 0 as PersoenlicheAnredeID,\r\n''<Alle>'' AS PersoenlicheAnrede\r\nFROM tblPersoenlicheAnreden\r\nUNION\r\nSELECT PersoenlicheAnredeID, PersoenlicheAnrede FROM tblPersoenlicheAnreden;<\/pre>\n
\n
\n
Private WithEvents frmParent As Form<\/pre>\n
Private frmDataSheet As Form<\/pre>\n
Private Sub Form_Open(Cancel As Integer)\r\n Dim ctl As control\r\n If IsNull(Me.OpenArgs) Then\r\n MsgBox "Das Suchformular kann nur von einem Formular mit zu durchsuchendem Unterformular " _\r\n & "geöffnet werden. Dessen Name ist als Öffungsargument zu übergeben."\r\n Cancel = True\r\n Else\r\n Set ctl = Screen.ActiveControl\r\n Set frmParent = ctl.Parent\r\n frmParent.OnUnload = "[Event Procedure]"\r\n Set frmDataSheet = frmParent(Me.OpenArgs).Form\r\n End If\r\nEnd Sub<\/pre>\n
frmParent.OnUnload = "[Event Procedure]"<\/pre>\n
Private Sub frmParent_Unload(Cancel As Integer)\r\n DoCmd.Close acForm, Me.Name\r\nEnd Sub<\/pre>\n
Private Sub Form_Load()\r\n Dim objSuchformularControl As clsSuchformularControl\r\n Set colSuchformularsteuerelemente = New Collection\r\n Me!cboAnredeID = Me!cboAnredeID.ItemData(0)\r\n Me!cboPersoenlicheAnredeID = Me!cboPersoenlicheAnredeID.ItemData(0)\r\n Dim ctl As control\r\n For Each ctl In Me.Controls\r\n Select Case ctl.ControlType\r\n Case acTextBox, acComboBox\r\n Set objSuchformularControl = New clsSuchformularControl\r\n With objSuchformularControl\r\n Set .SearchControl = ctl\r\n End With\r\n colSuchformularsteuerelemente.Add objSuchformularControl\r\n End Select\r\n Next ctl\r\nEnd Sub<\/pre>\n
Private Sub txtVorname_Change()\r\n txtVorname.Tag = txtVorname.Text\r\n If Me!chkSchnellsuche Then\r\n Suchen\r\n End If\r\nEnd Sub<\/pre>\n
Option Compare Database\r\nOption Explicit\r\nDim m_ctl As control\r\nDim WithEvents m_txt As TextBox\r\nDim WithEvents m_cbo As ComboBox\r\nPublic Property Set SearchControl(ctl As control)\r\n Set m_ctl = ctl\r\n Select Case m_ctl.ControlType\r\n Case acTextBox\r\n Set m_txt = m_ctl\r\n With m_txt\r\n .OnChange = "[Event Procedure]"\r\n End With\r\n Case acComboBox\r\n Set m_cbo = m_ctl\r\n With m_cbo\r\n .AfterUpdate = "[Event Procedure]"\r\n End With\r\n End Select\r\nEnd Property\r\nPrivate Sub m_cbo_AfterUpdate()\r\n If m_cbo.Parent.chkSchnellsuche Then\r\n m_cbo.Parent.Suchen\r\n End If\r\nEnd Sub\r\nPrivate Sub m_txt_Change()\r\n m_txt.Tag = m_txt.Text\r\n If m_txt.Parent.chkSchnellsuche Then\r\n m_txt.Parent.Suchen\r\n End If\r\nEnd Sub<\/pre>\n
Dim colSuchformularsteuerelemente As Collection<\/pre>\n
Set colSuchformularsteuerelemente = New Collection<\/pre>\n
For Each ctl In Me.Controls\r\n Select Case ctl.ControlType\r\n Case acTextBox, acComboBox\r\n Set objSuchformularControl = New clsSuchformularControl\r\n With objSuchformularControl\r\n Set .SearchControl = ctl\r\n End With\r\n colSuchformularsteuerelemente.Add objSuchformularControl\r\n End Select\r\nNext ctl<\/pre>\n
Dim WithEvents m_txt As TextBox<\/pre>\n
Private Sub m_txt_Change()\r\n m_txt.Tag = m_txt.Text\r\n If m_txt.Parent.chkSchnellsuche Then\r\n m_txt.Parent.Suchen\r\n End If\r\nEnd Sub<\/pre>\n
Private Sub m_cbo_AfterUpdate()\r\n If m_cbo.Parent.chkSchnellsuche Then\r\n m_cbo.Parent.Suchen\r\n End If\r\n End Sub<\/pre>\n
Private Sub cmdSuchen_Click()\r\n Suchen\r\nEnd Sub<\/pre>\n
Public Sub Suchen()\r\n Dim strSuchfilter As String\r\n strSuchfilter = SuchfilterErstellen\r\n If Len(strSuchfilter) > 0 Then\r\n frmDataSheet.Filter = strSuchfilter\r\n frmDataSheet.FilterOn = True\r\n Else\r\n frmDataSheet.Filter = ""\r\n frmDataSheet.FilterOn = False\r\n End If\r\nEnd Sub<\/pre>\n
Vorname LIKE ''A*''<\/pre>\n