Wer kennt das nicht als Entwickler: Man möchte mal eben schnell in einer Tabelle nach einem bestimmten Datensatz suchen. Und das auch noch wiederholt, sodass man immer noch den Filter entfernen und diesen neu setzen muss – wozu wir die eingebauten Filter-Elemente der Datenblattansicht nutzen. Viel schöner wäre es doch, wenn wir mal eben das Kriterium und weitere Einstellungen über das Ribbon steuern könnten – während wir die Daten beim Filtern betrachten. Genau dazu haben wir uns für den Eigenbedarf eine kleine Schnellsuche gebaut, die wir in diesem Beitrag vorstellen. Das Beste: Selbst wenn Sie gar nicht genau erfahren wollen, wie es funktioniert, finden Sie die Lösung für 32-Bit- und 64-Bit-Access im Download zu diesem Beitrag.<\/b><\/p>\n
Das Tool soll gar keine aufwendigen Aufgaben erledigen: Wir wollen schlicht und einfach im Ribbon ein Feld haben, in das wir einen Vergleichswert eingeben können. <\/p>\n
Die Suche wollen wir durch Betätigen der Eingabetaste oder einer Schaltfläche starten.<\/p>\n
Zum einen möchten wir nur das aktuell markierte Feld oder alle Felder nach dem gesuchten Inhalt filtern und zum anderen möchten wir festlegen, ob der gesamte Feldinhalt mit dem Suchbegriff übereinstimmen muss oder ob der Suchbegriff nur im Feld enthalten sein soll. All dies sehen wir in Bild 1. Hier haben wir das Textfeld zur Eingabe des Filters, die beiden Schaltflächen zum Aktivieren und Deaktivieren des Filters sowie die beiden Optionen für das Durchsuchen des kompletten Feldinhalts und für das aktuelle Feld oder alle Felder.<\/p>\n
![\"Ribbon-Funktion](\"..\/fileadmin\/_temp_\/2024_05\/pic_1497_001.png\")
<\/p>\n
Bild 1: Ribbon-Funktion zur Schnellsuche in Datenblättern und Formularen<\/span><\/b><\/p>\n Eine solche Erweiterung können wir einer einzelnen Access-Anwendung hinzufügen, indem wir die entsprechende Ribbondefinition anlegen und die dadurch aufgerufenen Funktionen hinzufügen.<\/p>\n Wir wollen diese Funktion allerdings in allen Access-Anwendungen nutzen, jedoch nicht die Funktion in alle Access-Anwendungen einbauen. Deshalb haben wir ein COM-Add-In auf Basis von twinBASIC programmiert. Wie das COM-Add-In funktioniert, zeigen wir in diesem Beitrag. Wenn Sie das COM-Add-In anpassen oder erweitern oder ein neues COM-Add-In auf Basis dieses Add-Ins erstellen wollen, sind Sie nach der Lektüre dieses Beitrags bestens gerüstet. Alles, was man braucht, ist die aktuelle Version der für 32-Bit-Anwendungen kostenlosen twinBASIC-Entwicklungsumgebung, zum Beispiel von hier:<\/p>\n Dabei handelt es sich um eine .exe<\/b>-Datei mit einigen weiteren Dateien, die Sie nur auf Ihre Festplatte extrahieren und starten müssen, zum Beispiel durch einen Doppelklick auf die Datei amvFastSearch.twinproj <\/b>aus dem Download zu diesem Beitrag.<\/p>\n Das Projekt enthält nur zwei Module. Das erste namens DllRegistration.twin<\/b> enthält lediglich die beiden Funktionen, die beim Registrieren und beim Aufheben der Registrierung durchgeführt werden sollen. Diese werden sowohl ausgeführt, wenn wir in twinBASIC den Befehl File|Build <\/b>aufrufen als auch dann, wenn wir die fertig erstellte .dll<\/b>-Datei mit dem Befehl Regsvr32.exe <\/b>registrieren. Diese enthalten die Informationen, die dann in die Registry geschrieben werden sollen und beim Start von Access ausgelesen werden. Weiter unten zeigen wir jedoch auch noch, wie die Registrierung über die Benutzeroberfläche funktioniert.<\/p>\n Ist das COM-Add-In einmal registriert, wird es beim Start von Access eingelesen und verschiedene Ereignisprozeduren der beiden Schnittstellen des COM-Add-Ins werden ausgelöst. Das COM-Add-In implementiert die beiden Schnittstellen IDTExtensibility2 <\/b>und IRibbonExtensibility<\/b>. Die erste sorgt dafür, dass das COM-Add-In beim Starten von Access ebenfalls gestartet wird und einen Verweis auf die Access-Instanz erhält. Die zweite enthält nur eine Funktion, mit der sich Access eine Ribbondefinition holen kann, die wir im COM-Add-In zusammenstellen.<\/p>\n Bevor wir uns die Prozeduren ansehen, die beim Start ausgelöst werden, werfen wir einen Blick auf einige Variablen, die wir im Kopf der Klasse amvFastSearch <\/b>unterbringen:<\/p>\n Die erste nimmt einen Verweis auf die Access-Instanz auf, die das COM-Add-In verwendet. Die zweite erhält nach dem Erstellen des Ribbons einen Objektverweis auf die Definition, damit wir darüber auf bestimmte Ereignisse reagieren können.<\/p>\n Die übrigen Variablen sind bereits für das Speichern der Informationen vorgesehen, die wir über die Ribbon-Benutzerschnittstelle des Tools eingeben.<\/p>\n Wenn Access gestartet wird und das COM-Add-In über die Registry als aktiv identifiziert, wird dieses aufgerufen und erhält über die Ereignisprozedur OnConnection<\/b> mit dem Parameter Application einen Verweis auf die aufrufende Access-Instanz. Dieser wird direkt in der Variablen objAccess <\/b>gespeichert:<\/p>\n Es gibt noch weitere Ereignisprozeduren für das COM-Add-In, aber die sind für uns nicht weiter interessant. Wichtig ist nur, dass sie überhaupt implementiert werden.<\/p>\n Die Funktion GetCustomUI <\/b>stellt die Ribbondefinition zusammen und gibt diese an Access zurück, damit diese dort angewendet werden kann (siehe Listing 1). Das Ribbon besteht aus einem customUI<\/b>-Element mit den Callback-Ereignissen loadImage <\/b>und onLoad<\/b>. Die für onLoad <\/b>hinterlegte Prozedur wird einmalig beim Einlesen der Ribbondefinition ausgeführt.<\/p>\n Listing 1: Zusammenstellen der Ribbondefinition <\/span><\/b><\/p>\n Diese nimmt einen Verweis auf die Ribbondefinition entgegen und speichert diese in der Variablen objRibbon<\/b>:<\/p>\n Die für das Attribut loadImage <\/b>hinterlegte Funktion loadImage <\/b>erwartet für den mit imageId <\/b>übergebenen Namen ein entsprechendes Objekt des Typs IPictureDisp<\/b>. Dieses holen wir mit der Funktion LoadResPicture <\/b>aus den Ressourcen des twinBASIC-Projekts:<\/p>\n In diesem COM-Add-In nutzen wir diese Funktion ehrlich gesagt gar nicht – aber wenn Sie weitere Funktionen hinzufügen wollen, deren Schaltflächen ein benutzerdefiniertes Icon aufweisen sollen, fügen Sie einfach die entsprechende .ico<\/b>-Datei zum Ordner Resources|ICON <\/b>des Projekts hinzu und hinterlegen den Namen für die Eigenschaft image<\/b> des jeweiligen Ribbonelements.<\/p>\n In der Ribbondefinition geht es weiter mit den Elementen ribbon<\/b>, tabs <\/b>und tab<\/b>. Als tab<\/b>-Element referenzieren wir das eingebaute tab<\/b>-Element TabHomeAccess<\/b>. Hier fügen wir ein group-Element ein, das wir hinter dem eingebauten Element GroupSortAndFilter <\/b>platzieren, also direkt hinter den standardmäßigen Sortier- und Filterfunktionen. Darin legen wir ein box<\/b>-Element an, dass die editBox <\/b>namens txtFilter <\/b>und die beiden button<\/b>-Elemente btnFilter <\/b>und btnFilterAus <\/b>gruppieren soll, damit diese in einer Zeile nebeneinander abgebildet werden.<\/p>\n Danach folgen noch die beiden checkBox<\/b>-Elemente chkKompletterFeldinhalt <\/b>und chkNurAktuellesFeldUntersuchen<\/b>. Anschließend werden die geöffneten Elemente group, tab<\/b>, tabs<\/b>, ribbon <\/b>und customUI <\/b>in umgekehrter Reihenfolge wieder geschlossen.<\/p>\n Das editBox<\/b>-Steuerelement haben wir mit den beiden Attributen onChange <\/b>und getText <\/b>ausgestattet. onChange wird ausgelöst, wenn der Benutzer den Inhalt ändert und die Änderung abschließt. Dies löst den folgenden Code aus:<\/p>\n Wir schreiben den Vergleichswert in die Variable strVergleichswert <\/b>und rufen die Prozedur Filter <\/b>auf, die das Filtern selbst erledigt. Auf diese kommen wir später zurück.<\/p>\n Die durch getText <\/b>ausgelöste Funktion liefert den aktuellen Wert von strVergleichswert <\/b>an das editBox<\/b>-Element zurück:<\/p>\n Wozu das sinnvoll ist, besprechen wir gleich im Anschluss.<\/p>\n Die Schaltfläche btnFilter <\/b>ruft mit onAction <\/b>die Prozedur onAction <\/b>auf, die wie folgt aussieht:<\/p>\n Sie erwartet mit dem Parameter control<\/b> einen Verweis auf das aufrufende button<\/b>-Element. Wenn wir den Button btnFilter <\/b>anklicken, sorgt dies für den Aufruf der Prozedur Filter<\/b>.<\/p>\n Wenn wir btnFilterAus <\/b>anklicken, wird strVergleichswert <\/b>auf eine leere Zeichenkette eingestellt. Außerdem rufen wir die Methode Invalidate <\/b>von objRibbon <\/b>auf und sorgen so dafür, dass alle get…<\/b>-Attribute erneut aus den entsprechenden Funktionen gefüllt werden müssen.<\/p>\n Dadurch wird auch das Textfeld geleert, indem es mit der leeren Zeichenkette aus strVergleichswert <\/b>gefüllt wird.<\/p>\n Damit wird erneut die Prozedur Filter ausgelöst, die bei leerem Vergleichskriterium den Filter deaktiviert.<\/p>\n Wenn der Benutzer das checkBox<\/b>-Element chkKompletterFeldinhalt <\/b>anklickt, löst er die Prozedur OnAction_Checkbox <\/b>aus. Diese prüft wieder, von welcher Checkbox sie ausgelöst wurde:<\/p>\n Sie stellt die jeweilige Variable, also bolKompletterFeldinhalt <\/b>oder bolNurAktuellesFeldUntersuchen<\/b>, auf den aktuellen Wert des entsprechenden Kontrollkästchens ein. Danach ruft auch sie wieder die Filter<\/b>-Prozedur auf, damit der Filter an die geänderten Optionen angepasst werden kann.<\/p>\n Damit haben wir alle Ribbon-Elemente erläutert und können uns endlich um die Filter<\/b>-Prozedur kümmern (erster Teil siehe Listing 2). Sie versucht zunächst, das aktive Steuerelement mit objAccess.Screen.ActiveControl <\/b>zu referenzieren. Der Hintergrund ist, es auch kein Objekt gibt, dessen Inhalt gefiltert werden kann.<\/p>\n Listing 2: Prozedur zum Filtern des Datenblatts (Teil 1)<\/span><\/b><\/p>\n Der Bezug über objAccess <\/b>ist wichtig, weil das COM-Add-In die Screen<\/b>-Klasse an sich ja gar nicht kennt. Wenn die Variable ctl <\/b>anschließend nicht mit einem Verweis auf ein Steuerelement gefüllt ist, erscheint eine Meldung, die den Benutzer darauf hinweist, ein entsprechendes Steuerelement zu markieren. Außerdem wird die Prozedur an dieser Stelle verlassen. Anschließend versuchen wir, das Recordset des Parent<\/b>-Elements des Steuerelements aus Screen.ActiveControl <\/b>zu ermitteln. Liefert dies kein Recordset<\/b>-Element, erscheint ebenfalls eine entsprechende Meldung und die Prozedur endet hier.<\/p>\n Läuft die Prozedur nach dieser Prüfung noch, haben wir bereits zwei Informationen: Es hat ein Steuerelement den Fokus, dessen übergeordnetes Element ein Recordset<\/b>-Objekt verwendet. Damit können wir zur nächsten Prüfung übergehen: Handelt es sich um ein gebundenes Steuerelement? Dazu weisen wir der Variablen strField <\/b>den Inhalt von objAccess.Screen.ActiveControl.ControlSource <\/b>zu. Diese Eigenschaft ist nur für gebundene Steuerelemente gefüllt. Ist Len(strField) <\/b>anschließend also leer, haben wir kein gebundenes Steuerelement und somit auch keine Grundlage zum Durchsuchen der Datensätze.<\/p>\n Erst danach können wir in das Zusammensetzen des Filters einsteigen (siehe Listing 3). Als Erstes untersuchen wir nun den Wert der Variablen strVergleichswert<\/b>. Diese wird nach jeder Änderung des Steuerelements txtFilter <\/b>im Ribbon mit dem dort enthaltenen Wert aktualisiert. Liefert Len(strVergleichswert) <\/b>den Wert 0<\/b>, leeren wir den Filter des Datenblatts, indem wir objAccess.Screen.ActiveControl.Parent.Filter <\/b>auf eine leere Zeichenkette einstellen.<\/p>\n Listing 3: Prozedur zum Filtern des Datenblatts (Teil 2)<\/span><\/b><\/p>\n Hat strVergleichswert <\/b>jedoch einen Wert, untersuchen wir die weiteren Bedingungen anhand der Werte für die Variablen bolNurAktuellesFeld<\/b> und bolKompletterFeldinhalt<\/b>.<\/p>\n Zunächst bearbeiten wir den Fall, dass beide Variablen den Wert True <\/b>enthalten, dass wir also den Suchbegriff mit dem kompletten Inhalt des aktuellen Feldes abgleichen wollen. In diesem Fall stellen wir einen Filterausdruck zusammen, der beispielsweise so lautet:<\/p>\n Wenn bolKompletterFeldinhalt <\/b>den Wert False <\/b>enthält, wird daraus dieses Kriterium:<\/p>\n Durch die Sternchen kann der Suchausdruck also an beliebiger Stelle im Feldinhalt enthalten sein. Wenn bolNurAktuellesFeld <\/b>den Wert False <\/b>enthält, sollen alle Felder mit dem Vergleichswert verglichen werden. Hier nutzen wir nun das weiter oben bereits ermittelte Recordset. In einer For Each<\/b>-Schleife durchlaufen wir alle Elemente der Fields<\/b>-Auflistung und referenzieren das aktuelle Element mit der Variablen fld<\/b>.<\/p>\n In der Schleife unterscheiden wir nach Feldern, deren Inhalt mit Zeichenketten verglichen werden kann und solchen, bei denen das nicht möglich ist. Dabei lassen wir die Datentypen dbAttachment<\/b>, dbComplexByte<\/b>, dbComplexDecimal<\/b>, dbComplexDouble<\/b>, dbComplexGUID<\/b>, dbComplexInteger<\/b>, dbComplexLong<\/b>, dbComplexSingle<\/b>, dbComplexText<\/b>, dbLongBinary <\/b>und dbVarBinary <\/b>außen vor. Für alle anderen prüfen wir wieder zuerst, ob der komplette Feldinhalt untersucht werden soll oder ob auch Teilinhalte als Fundstellen gelten.<\/p>\n Im ersteren Fall stellen wir nun in strFilter <\/b>eine Zeichenkette zusammen, die beispielsweise wie folgt aussehen würde, wenn das Recordset nur die beiden Felder Vorname <\/b>und Nachname <\/b>enthalten würde:<\/p>\n Wenn auch Teilzeichenketten gültig sind, kommen noch die Sternchen als Platzhalter zu unserem Filter-Ausdruck hinzu:<\/p>\n Schließlich stellen wir die Eigenschaft FilterOn <\/b>für das übergeordnete Objekt auf True <\/b>ein, damit der Filter aktiviert wird.<\/p>\n Sie können das COM-Add-In nun mit dem Menübefehl File|Build <\/b>erstellen. Achten Sie dabei darauf, dass wenn es bereits einmal erstellt wurde und aktuell eine Access-Instanz läuft, keine Neuerstellung möglich ist, weil die vorhandene DLL nicht gelöscht werden kann – diese ist in Benutzung. Sie sollten also zunächst alle Access-Instanzen beenden. Treten dann Probleme bei der Erstellung auf, kann dies daran liegen, dass noch eine Access-Instanz im Hintergrund läuft. Diese lässt sich nur über den Task-Manager beenden.<\/p>\n Wenn Sie das COM-Add-In auf dem eigenen Rechner erstellen, werden direkt die notwendigen Registry-Einträge erstellt, die dafür sorgen, dass das COM-Add-In beim nächsten Start von Access erkannt und aufgerufen wird.<\/p>\n Um das COM-Add-In aus der Registrierung zu entfernen, wechseln Sie im twinBASIC-Projekt zur Datei DllRegistration.twin<\/b>. Hier führen Sie die Prozedur DllUnregisterServer <\/b>aus. Auch dazu darf aktuell keine Access-Instanz geöffnet sein und auf die DLL zugreifen.<\/p>\n Wenn Sie es auf einem anderen Rechner installieren wollen, sind nur die folgenden Schritte nötig:<\/p>\nCOM-Add-In mit twinBASIC<\/h2>\n
https:\/\/github.com\/twinbasic\/twinbasic\/releases<\/pre>\n
Code des COM-Add-Ins<\/h2>\n
Beim Start des COM-Add-Ins<\/h2>\n
Private <\/span>objAccess As <\/span>Access.Application\r\nPrivate <\/span>objRibbon As <\/span>IRibbonUI\r\nPrivate <\/span>bolKompletterFeldinhalt As Boolean<\/span>\r\nPrivate <\/span>bolNurAktuellesFeld As Boolean<\/span>\r\nPrivate <\/span>strVergleichswert As String<\/span><\/pre>\nBeim Verbinden des COM-Add-Ins<\/h2>\n
Sub <\/span>OnConnection(ByVal Application As Object<\/span>, _\r\n ByVal ConnectMode As <\/span>ext_ConnectMode, _\r\n ByVal AddInInst As Object<\/span>, _\r\n ByRef custom As Variant<\/span>()) _\r\n Implements IDTExtensibility2.OnConnection\r\n Set<\/span> objAccess = Application\r\nEnd Sub<\/span><\/pre>\nRibbondefinition zusammenstellen<\/h2>\n
Private Function <\/span>GetCustomUI(ByVal RibbonID As String<\/span>) As String<\/span> Implements IRibbonExtensibility.GetCustomUI\r\n Dim <\/span>strXML As String<\/span>\r\n strXML &= \"<customUI xmlns=\"\"http:\/\/schemas.microsoft.com\/office\/2009\/07\/customui\"\" loadImage=\"\"LoadImage\"\" \" _\r\n & \"onLoad=\"\"onLoad\"\">\" & vbCrLf<\/span>\r\n strXML &= \" <ribbon startFromScratch=\"\"false\"\">\" & vbCrLf<\/span>\r\n strXML &= \" <tabs>\" & vbCrLf<\/span>\r\n strXML &= \" <tab idMso=\"\"TabHomeAccess\"\">\" & vbCrLf<\/span>\r\n strXML &= \" <group id=\"\"grpFastSearch\"\" label=\"\"Schnellsuche\"\" insertAfterMso=\"\"GroupSortAndFilter\"\">\" _\r\n & vbCrLf<\/span>\r\n strXML &= \" <box id=\"\"box1\"\">\" & vbCrLf<\/span>\r\n strXML &= \" <editBox label=\"\"Filtern nach:\"\" id=\"\"txtFilter\"\" sizeString=\"\"aaaaaaaaaaaaaaaaa\"\" \" _\r\n & \"onChange=\"\"onChange\"\" getText=\"\"getText\"\"\/>\" & vbCrLf<\/span>\r\n strXML &= \" <button imageMso=\"\"FilterToggleFilter\"\" id=\"\"btnFilter\"\" onAction=\"\"onAction\"\"\/>\" & vbCrLf<\/span>\r\n strXML &= \" <button imageMso=\"\"FilterClearAllFilters\"\" id=\"\"btnFilterAus\"\" onAction=\"\"onAction\"\"\/>\" _\r\n & vbCrLf<\/span>\r\n strXML &= \" <\/box>\" & vbCrLf<\/span>\r\n strXML &= \" <checkBox label=\"\"Kompletten Feldinhalt untersuchen\"\" id=\"\"chkKompletterFeldinhalt\"\" \" _\r\n & \"onAction=\"\"OnAction_Checkbox\"\"\/>\" & vbCrLf<\/span>\r\n strXML &= \" <checkBox label=\"\"Nur aktuelles Feld untersuchen\"\" id=\"\"chkNurAktuellesFeldUntersuchen\"\" \" _\r\n & \"onAction=\"\"OnAction_Checkbox\"\"\/>\" & vbCrLf<\/span>\r\n strXML &= \" <\/group>\" & vbCrLf<\/span>\r\n strXML &= \" <\/tab>\" & vbCrLf<\/span>\r\n strXML &= \" <\/tabs>\" & vbCrLf<\/span>\r\n strXML &= \" <\/ribbon>\" & vbCrLf<\/span>\r\n strXML &= \"<\/customUI>\" & vbCrLf<\/span>\r\n Return strXML\r\nEnd Function<\/span><\/pre>\nFunction <\/span>OnLoad(ribbon As <\/span>IRibbonUI)\r\n Set<\/span> objRibbon = ribbon\r\nEnd Function<\/span><\/pre>\nFunction <\/span>LoadImage(imageId As String<\/span>) As <\/span>IPictureDisp\r\n Return LoadResPicture(imageId, _\r\n vbResBitmapFromIcon, 32, 32)\r\nEnd Function<\/span><\/pre>\nFunktionen der Steuerelemente im Ribbon<\/h2>\n
Sub <\/span>OnChange(control As <\/span>IRibbonControl, text As String<\/span>)\r\n strVergleichswert = text\r\n Call<\/span> Filter()\r\nEnd Sub<\/span><\/pre>\nFunction <\/span>GetText(control As <\/span>IRibbonControl) As String<\/span>\r\n Return strVergleichswert\r\nEnd Function<\/span><\/pre>\nFunktionen der Schaltflächen<\/h2>\n
Public Sub <\/span>OnAction(control As <\/span>IRibbonControl)\r\n Select Case control.Id\r\n Case <\/span>\"btnFilter\"\r\n Call<\/span> Filter\r\n Case <\/span>\"btnFilterAus\"\r\n strVergleichswert = \"\"\r\n Call<\/span> objRibbon.Invalidate()\r\n Call<\/span> Filter\r\n Case Else<\/span>\r\n MsgBox<\/span> \"OnAction nicht behandelt: \" & control.Id\r\n End Select<\/span>\r\nEnd Sub<\/span><\/pre>\ncheckbox-Elemente<\/h2>\n
Sub <\/span>OnAction_Checkbox(control As <\/span>IRibbonControl, _\r\n pressed As Boolean<\/span>)\r\n Select Case control.Id\r\n Case <\/span>\"chkKompletterFeldinhalt\"\r\n bolKompletterFeldinhalt = pressed\r\n Case <\/span>\"chkNurAktuellesFeldUntersuchen\"\r\n bolNurAktuellesFeld = pressed\r\n End Select<\/span>\r\n Call<\/span> Filter(True<\/span>)\r\nEnd Sub<\/span><\/pre>\nFilter-Prozedur<\/h2>\n
Private Sub <\/span>Filter(Optional<\/span> bolCheckbox As Boolean<\/span>)\r\n Dim <\/span>strField As String<\/span>\r\n Dim <\/span>rst As <\/span>DAO.Recordset\r\n Dim <\/span>fld As <\/span>DAO.Field\r\n Dim <\/span>strFilter As String<\/span>\r\n Dim <\/span>ctl As Object<\/span>\r\n On Error Resume Next<\/span>\r\n Set<\/span> ctl = objAccess.Screen.ActiveControl\r\n If <\/span>ctl Is Nothing Then<\/span>\r\n MsgBox<\/span> \"Bitte markiere ein Steuerelement innerhalb des zu filternden Datenblatts.\", vbOKOnly + _\r\n vbExclamation, \"amvFastSearch\"\r\n Exit Sub<\/span>\r\n End If<\/span>\r\n Set<\/span> rst = objAccess.Screen.ActiveControl.Parent.recordset\r\n If <\/span>rst Is Nothing Then<\/span>\r\n If <\/span>bolCheckbox = False<\/span> Then<\/span>\r\n MsgBox<\/span> \"Für diese Funktion muss ein Feld in einem Datenblatt den Fokus haben.\", vbOKOnly _\r\n + vbExclamation, \"amvFastSearch\"\r\n End If<\/span>\r\n Exit Sub<\/span>\r\n End If<\/span>\r\n strField = objAccess.Screen.ActiveControl.ControlSource\r\n If <\/span>Len<\/span>(strField) = 0 Then<\/span>\r\n MsgBox<\/span> \"Für diese Funktion muss ein Feld im Datenblatt den Fokus haben.\", vbOKOnly + vbExclamation, _\r\n \"amvFastSearch\"\r\n Exit Sub<\/span>\r\n End If<\/span>\r\n On Error GoTo<\/span> 0\r\n ...<\/pre>\n ...\r\n If <\/span>Len<\/span>(strVergleichswert) = 0 Then<\/span>\r\n objAccess.Screen.ActiveControl.Parent.Filter = \"\"\r\n Else<\/span>\r\n If <\/span>bolNurAktuellesFeld Then<\/span>\r\n If <\/span>bolKompletterFeldinhalt = True<\/span> Then<\/span>\r\n strFilter = strField & \" LIKE ''\" & strVergleichswert & \"''\"\r\n objAccess.Screen.ActiveControl.Parent.Filter = strFilter\r\n Else<\/span>\r\n strFilter = strField & \" LIKE ''*\" & strVergleichswert & \"*''\"\r\n objAccess.Screen.ActiveControl.Parent.Filter = strFilter\r\n End If<\/span>\r\n Else<\/span>\r\n For Each fld In rst.Fields\r\n Select Case fld.Type\r\n Case <\/span>dbAttachment, dbComplexByte, dbComplexDecimal, dbComplexDouble, dbComplexGUID, _\r\n dbComplexInteger, dbComplexLong, dbComplexSingle, dbComplexText, dbLongBinary, dbVarBinary\r\n Case Else<\/span>\r\n If <\/span>bolKompletterFeldinhalt = True<\/span> Then<\/span>\r\n strFilter = strFilter & \" OR \" & fld.Name & \" LIKE ''\" & strVergleichswert & \"''\"\r\n Else<\/span>\r\n strFilter = strFilter & \" OR \" & fld.Name & \" LIKE ''*\" & strVergleichswert & \"*''\"\r\n End If<\/span>\r\n End Select<\/span>\r\n Next<\/span> fld\r\n If <\/span>Not<\/span> Len<\/span>(strFilter) = 0 Then<\/span>\r\n strFilter = Mid<\/span>(strFilter, 4)\r\n End If<\/span>\r\n objAccess.Screen.ActiveControl.Parent.filter = strFilter\r\n End If<\/span>\r\n objAccess.Screen.ActiveControl.Parent.filteron = True<\/span>\r\n End If<\/span>\r\nEnd Sub<\/span><\/pre>\nVorname LIKE ''André''<\/pre>\n
Vorname LIKE ''*André*''<\/pre>\n
Vorname LIKE ''Minhorst'' OR Nachname LIKE ''Minhorst''<\/pre>\n
Vorname LIKE ''*Minhorst*'' OR Nachname LIKE ''*Minhorst*''<\/pre>\n
COM-Add-In erstellen<\/h2>\n
COM-Add-In auf einem anderen Rechner installieren<\/h2>\n
![\"Hinzufügen](\"..\/fileadmin\/_temp_\/2024_05\/pic_1497_002.png\")
<\/p>\n