<\/p>\n
\n
Neulich wollte ich mal meine Artikeldatenbank nach bestimmten Suchbegriffen durchforsten. Also habe ich mir eine Abfrage gebaut, die nur die relevanten Felder der zu durchsuchenden Tabelle enthält. Dort dachte ich dann, ich könnte mit der eingebauten Filter-Funktion des Datenblatts schnell zu den gesuchten Fundstellen gelangen. Das Ergebnis war ernüchternd, denn Access lieferte zwar alle passenden Datensätze, aber in den recht langen Texten innerhalb der Datensätze musste ich dann nochmals nach dem gesuchten Text suchen. Das konnte ich nicht auf mir sitzen lassen und habe eine Suchfunktion mit Fundstellen programmiert, die dieser Beitrag vorstellt.<\/b><\/p>\n
Normalerweise würde man im Datenblatt mit der Maus auf Pfeil nach unten rechts im Spaltenkopf klicken, dann den Menüeintrag Textfilter|Enthält… <\/b>auswählen, den Suchbegriff eingeben und dann die Suchergebnisse betrachten. Das gelingt auch grundsätzlich, wie Bild 1 zeigt. Aber wie eingangs erwähnt, wird auf diese Weise nicht die Fundstelle markiert.<\/p>\n
![\"Filtern](\"..\/fileadmin\/_temp_\/2018_01\/pic_1119_001.png\")
<\/p>\n
Bild 1: Filtern nach Suchausdruck<\/span><\/b><\/p>\n Dies erreichen wir etwas besser, wenn wir die Suchen und Ersetzen<\/b>-Funktion nutzen, die wir über den Ribbon-Eintrag Start|Suchen|Suchen <\/b>öffnen. Diese springt so zur Fundstelle, dass diese meist ganz unten im sichtbaren Teil des Textes angezeigt wird (s. Bild 2). Auch das ist nur bedingt praxistauglich, da so nur jeweils ein Eintrag gleichzeitig angezeigt wird. Also benötigen wir eine alternative Lösung.<\/p>\n Bild 2: Einsatz der Suchen und Ersetzen-Funktion<\/span><\/b><\/p>\n Statt der nicht perfekten Lösung durch die eingebauten Elemente der Access-Datenblattansicht wollen wir eine benutzerdefinierte Lösung entwickeln. Diese soll die Fundstellen ebenfalls in einer Datenblattansicht anzeigen. Allerdings wollen wir auch nur die Fundstelle erhalten und nicht den kompletten Text des durchsuchten Inhalts.<\/p>\n Und der gesuchte Begriff soll farbig hervorgehoben werden, damit wir ihn direkt erkennen! Da wir meist Texte mit mehreren Absätzen haben, wollen wir außerdem einstellen können, wie viele Absätze vor und nach dem Absatz mit dem Suchbegriff ausgegeben werden sollen. <\/p>\n Wir kümmern uns zunächst um die einfache Variante der Prozedur, die nach dem Eingeben eines Suchbegriffs und dem Betätigen der Taste cmdSuchen <\/b>ausgelöst wird.<\/p>\n Wenn wir einen oder mehrere längere Texte nach einem Suchbegriff durchsuchen, erhalten wir gegebenenfalls mehrere Suchergebnisse beziehungsweise Fundstellen. Um dem Benutzer diese anzuzeigen, speichern wir sie in einer Tabelle und geben den Inhalt der Tabelle dann in einem Formular aus. Die Tabelle zum Speichern der Fundstellen heißt tblFundstellen <\/b>und sieht im Entwurf wie in Bild 3 aus. Neben dem Primärschlüsselfeld enthält die Tabelle ein Feld zum Speichern der ID des Beitrags, aus dem die Fundstelle stammt, sowie die Fundstelle selbst.<\/p>\n Bild 3: Tabelle zum Speichern der Fundstellen<\/span><\/b><\/p>\n Dabei soll es sich zunächst um die Zeile mit dem gefundenen Begriff und zur zusätzlichen Orientierung noch die vorherige und die folgende Zeile handeln.<\/p>\n Da wir den Suchbegriff selbst in der Fundstelle als Richtext farbig markieren wollen, stellen wir für die Eigenschaft Textformat <\/b>des Feldes Fundstelle <\/b>den Wert Rich-Text <\/b>ein.<\/p>\n Die Daten der Tabelle sollen in einem Unterformular namens sfmVolltextsuche <\/b>ausgegeben werden. Dazu binden wir dieses Unterformular an die Tabelle tblFundstellen <\/b>und ziehen das Feld Fundstelle <\/b>aus der Feldliste in den Entwurf dieses Formulars (s. Bild 4).<\/p>\n Bild 4: Entwurf des Unterformulars zur Anzeige der Fundstellen<\/span><\/b><\/p>\n Da wir in dieses Unterformular weder Daten eingeben noch vorhandene Daten bearbeiten oder löschen wollen, stellen wir die Eigenschaften Anfügen zulassen<\/b>, Löschen zulassen <\/b>und Bearbeiten zulassen <\/b>jeweils auf den Wert Nein <\/b>ein.<\/p>\n Das Hauptformular der Lösung enthält die folgenden Steuer-elemente:<\/p>\n Die Steuer-elemente werden wie in Bild 5 angeordnet. Damit die Suche nach der Eingabe des Suchbegriffs in das Textfeld txtSuchbegriff <\/b>sowohl durch das Betätigen der Eingabetaste als auch durch einen Mausklick auf die Schaltfläche cmdSuchen <\/b>ausgelöst werden kann, stellen wir die Eigenschaft Standard <\/b>der Schaltfläche cmdSuchen <\/b>auf Ja <\/b>ein.<\/p>\n Bild 5: Entwurf des Hauptformulars<\/span><\/b><\/p>\n Damit das Unterformular mit den Suchstellen vergrößert wird, wenn der Benutzer das Hauptformular vergrößert, stellen wir die beiden Eigenschaften Horizontaler Anker <\/b>und Vertikaler Anker <\/b>jeweils auf den Wert Beide <\/b>ein. Damit das Textfeld txtFundstelle <\/b>nach unten verschoben wird, wenn der Benutzer die Höhe des Formulars vergrößert, stellen wir die Eigenschaft Vertikaler Anker <\/b>dieses Steuerelements auf den Wert Unten <\/b>ein.<\/p>\n Zieht der Benutzer das Formular in die Breite, soll auch das Textfeld verbreitert werden, also erhält die Eigenschaft Horizontaler Anker <\/b>den Wert Beide<\/b>.<\/p>\n Das Formular soll an die Tabelle mit den zu durchsuchenden Texten gebunden sein, damit sie den kompletten Text zur aktuell im Unterformular markierten Fundstelle schnell anzeigen kann.<\/p>\n Deshalb stellen wir die Eigenschaft Datenherkunft <\/b>des Formulars auf eine Abfrage namens qryInhalt <\/b>ein, die wiederum folgenden SQL-Ausdruck enthält und somit nur den Primärschlüsselwert des betroffenen Beitrags sowie seinen vollständigen Text enthält:<\/p>\n Die MSForms-TextBox binden wir über die Eigenschaft Steuerelementinhalt <\/b>an das Feld Inhalt <\/b>dieser Abfrage.<\/p>\n Um das Formular und die Steuer-elemente zu initialisieren, legen wir zwei Ereignisprozeduren an. Die erste soll durch das Ereignis Beim öffnen <\/b>des Formulars ausgelöst werden und die gegebenenfalls noch vorhandenen Einträge in der Tabelle tblFundstellen <\/b>löschen.<\/p>\n Diese Prozedur sieht wie folgt aus:<\/p>\n Die zweite Prozedur löst das Ereignis Beim Laden <\/b>aus. Dort initialisieren wir eine Variable zum Referenzieren der MSForms-TextBox, die wie folgt deklariert wird:<\/p>\n Die durch das Ereignis Beim Laden <\/b>ausgelöste Prozedur hat folgenden Code:<\/p>\n Hier stellen wir vor allem die Eigenschaften der MSForms-TextBox txtFundstelle <\/b>ein (Details siehe Beitrag Die MSForms-TextBox<\/b>, www.access-im-unternehmen.de\/1114<\/b>). Außerdem referenzieren wir auch noch das Unterformular mit einer Variablen namens sfm<\/b>. Auch diese soll im Kopf des Klassenmoduls deklariert werden, und zwar wie folgt:<\/p>\n Das Schlüsselwort WithEvents <\/b>verwenden wir, weil wir im Hauptformular auf die Ereignisse des Unterformulars reagieren wollen, in diesem Fall auf das Ereignis Beim Anzeigen<\/b>. Deshalb stellen wir die Eigenschaft OnCurrent <\/b>von sfm <\/b>auf den Wert [Event Procedure] <\/b>ein. Die passende Ereignisprozedur können wir auch gleich vorstellen:<\/p>\n Die hier aufgerufene Prozedur EintragAnzeigen <\/b>besprechen wir jedoch weiter unten.<\/p>\n Wenn der Benutzer einen Suchbegriff in das Textfeld txtSuchbegriff <\/b>eingegeben hat und entweder die Eingabetaste betätigt oder auf die Schaltfläche cmdSuchen<\/b> klickt, löst er damit die Ereignisprozedur cmdSuchen_Click <\/b>aus, die Sie in Listing 1 finden.<\/p>\n Listing 1: Diese Prozedur wird beim Klick auf die Schaltfläche cmdSuchen ausgelöst.<\/span><\/b><\/p>\n Diese Prozedur prüft zunächst, ob das Textfeld txtSuchbegriff <\/b>überhaupt einen Suchbegriff enthält. Ist das nicht der Fall, erscheint eine entsprechende Meldung und die Prozedur wird beendet.<\/p>\n Anderenfalls speichert die Prozedur den Suchbegriff aus dem Textfeld in der Variablen strSuche <\/b>und aktiviert die Anzeige der Sanduhr. Dann füllt sie die Variable db <\/b>mit einem Verweis auf das aktuelle Database<\/b>-Objekt. Die Variable rst <\/b>erhält ein Recordset, das alle Datensätze der Tabelle tblBeitraege <\/b>enthält, deren Feld TextRoh <\/b>das Suchergebnis enthält.<\/p>\n Damit filtern wir alle Einträge der Tabelle heraus, die als Quelle für Fundstellen infrage kommen. Die folgende Anweisung löscht dann alle gegebenenfalls noch vorhandenen Einträge der Tabelle tblFundstellen<\/b>.<\/p>\n Anschließend durchläuft die Prozedur alle Datensätze des Recordsets aus rst<\/b>, also die Datensätze der Tabelle tblBeitraege<\/b>, die den gesuchten Begriff enthalten.<\/p>\n Dabei ruft sie für jeden Datensatz die Prozedur TextDurchsuchen <\/b>auf und übergibt den zu durchsuchenden Text, den Suchbegriff, die ID des Beitrags sowie einen Verweis auf das Database<\/b>-Objekt der aktuellen Datenbank. Diese Prozedur schauen wir uns gleich im Detail an. Nur so viel: Sie durchsucht den kompletten Text nach Fundstellen und trägt diese dann in die Tabelle tblFundstellen <\/b>ein.<\/p>\n Ist dies erledigt und die Tabelle tblFundstellen <\/b>mit einigen Einträgen gefüllt, wird das Unterformular, das ja an diese Tabelle gebunden ist, aktualisiert.<\/p>\n Sollte keine Fundstelle vorhanden sein, wird der Filter des Hauptformulars über die Eigenschaft Filter <\/b>auf 1=2 <\/b>eingestellt, was einem Filter entspricht, der keinen Datensatz zurückliefert. Wurden jedoch Einträge gefunden, wird der Filter geleert, sodass alle Einträge der zugrunde liegenden Tabelle über die Datenherkunft verfügbar sind, und die Prozedur EintragAnzeigen <\/b>aufgerufen. Auch diese schauen wir uns weiter unten an. Mit dem Ausblenden des Sanduhr-Symbols ist die Suche beendet.<\/p>\n Die Prozedur TextDurchsuchen <\/b>nimmt sich den in einem Datensatz der Tabelle tblBeitraege <\/b>gespeicherten Text vor und durchsucht ihn nach allen Vorkommen des gesuchten Textes (s. Listing 2). Sie erwartet den Text (strInhalt<\/b>), den Suchbegriff (strSuche<\/b>), die ID des Datensatzes, aus dem der Inhalt stammt und einen Verweis auf das Database<\/b>-Objekt der aktuellen Datenbank als Parameter.<\/p>\n <\/p>\n Listing 2: Diese Prozedur ermittelt alle Vorkommen des Suchbegriffs.<\/span><\/b><\/p>\n Die Prozedur stellt zunächst den Wert der Variablen bol-ErsteZeile <\/b>auf den Wert False <\/b>ein. Diese Variable gibt an, ob sich bereits in der ersten Zeile eine Fundstelle befindet – wir gehen davon aus, dass dies nicht der Fall ist. Dann ermittelt die folgende Anweisung mit der InStr<\/b>-Funktion die tatsächliche Position der ersten Fundstelle. Ist lngPosStart<\/b>, also die Position der Fundstelle, ungleich 0<\/b>, steigt die Prozedur in eine Do While<\/b>-Schleife ein, die solange läuft, bis keine weitere Fundstelle mehr gefunden werden kann, sprich: bis lngPosStart <\/b>gleich 0 <\/b>ist.<\/p>\n Ist also eine Fundstelle vorhanden, ermittelt die Prozedur zunächst die Position des letzten Zeilenumbruchs (vbCrLf<\/b>) vor der Fundstelle. Befindet sich die Fundstelle also etwa irgendwo in der dritten Zeile des Textes aus strInhalt<\/b>, dann sucht die Prozedur nun die Position des Starts der Zeile und trägt die Position in die Variable lngStart <\/b>ein.<\/p>\n Die hier verwendete Funktion InStrRev<\/b> erhält den Inhalt von strInhalt<\/b> als zu durchsuchenden Text, die Konstante für einen Zeilenumbruch zu suchende Zeichenfolge und die Position der aktuellen Fundstelle als Beginn der Suche.<\/p>\n Diese läuft bei der Funktion InStrRev<\/b> im Gegensatz zur Funktion InStr <\/b>rückwärts, also in Richtung des Anfangs des Textes. Liefert lngStart <\/b>den Wert 0<\/b>, befindet sich die Fundstelle tatsächlich in der ersten Zeile. In diesem Falle wird lngStart <\/b>auf 1 <\/b>eingestellt und bolErsteZeile <\/b>erhält den Wert True<\/b>.<\/p>\n In der aktuellen Version der Prozedur wollen wir immer die Zeile mit der Fundstelle, die Zeile davor und die Zeile danach als Fundstelle speichern. Wir haben nun in lngStart <\/b>die Startposition der Zeile mit der Fundstelle gespeichert.<\/p>\n Nun rufen wir erneut InStrRev <\/b>auf, diesmal mit der Position aus lngStart <\/b>als Startposition, und speichern die Position des letzten vor dieser Position befindlichen Zeilenumbruchs wieder in der Variablen lngStart<\/b>. Wir springen also mit der in lngStart<\/b> gespeicherten Position nicht an den Anfang der Zeile, in der sich der Suchbegriff befindet, sondern an den Anfang der vorherigen Zeile (sofern sich dort noch eine Zeile befindet).<\/p>\n Danach ermitteln wir das Ende der Zeile, in der sich das Suchergebnis befindet, in dem wir mit der InStr<\/b>-Funktion das nächste Vorkommen der Konstanten vbCrLf <\/b>suchen und dessen Position in der Variablen lngEnde <\/b>speichern.<\/p>\n Dies wiederholen wir nochmals ab der Position, die sich zwei Zeichen hinter dieser Position befindet, und ermitteln so die Position des Endes der Zeile hinter der Zeile mit der Fundstelle.<\/p>\n Auch hier kann es wieder sein, dass die Zeile mit der Fundstelle nicht mit einem Zeilenumbruch abgeschlossen wird – was bedeutet, dass die Zeile mit der Fundstelle die letzte Zeile in strInhalt <\/b>ist.<\/p>\n Nun kommt eine Fallunterscheidung, welchen Ausschnitt des Textes wir speichern wollen. Die erste If…Then<\/b>-Bedingung prüft, ob sich die Fundstelle in der ersten Zeile befindet. Falls nicht, folgt eine weitere Fallunterscheidung – nämlich die, ob der Wert von lngEnde <\/b>größer ist als der von lngStart<\/b>. Dies ist nur dann nicht der Fall, wenn lngEnde <\/b>gleich 0 <\/b>ist, also die Zeile mit der Fundstelle die letzte Zeile in strInhalt <\/b>ist. In diesem Fall liest die Prozedur den Bereich von der Position lngStart + 2 <\/b>(also ohne das führende vbCrLf<\/b>) bis zur Position lngEnde – 2 <\/b>(ohne das abschließende vbCrLf<\/b>) in die Variable strAusschnitt <\/b>ein.<\/p>\n Sollte lngEnde <\/b>gleich 0 <\/b>sein und somit nicht größer als lngStart<\/b>, dann liest die Prozedur nur den Ausschnitt von der Position lngStart + 2 <\/b>bis zum Ende von strInhalt <\/b>in die Variable strAusschnitt <\/b>ein. <\/p>\n Fehlt noch der Fall, dass es sich bei der Zeile mit der Fundstelle um die erste Zeile handelt, also bolErsteZeile <\/b>den Wert True <\/b>enthält: In diesem Fall liest die Prozedur den Text von der Startposition aus lngStart + 1 <\/b>bis zur Endposition mit lngEnde – 2 <\/b>in die Variable strAusschnitt <\/b>ein.<\/p>\n Danach ersetzt die Prozedur im Ausschnitt alle Kleiner- und Größer-Zeichen durch entsprechende Escape-Sequenzen, also etwa < <\/b>oder ><\/b>, damit diese bei der Darstellung als Richtext korrekt interpretiert werden.<\/p>\n Dann folgt eine wichtige Zeile: Diese ersetzt nämlich im Text aus strAusschnitt<\/b> den gefundenen Inhalt durch den gleichen Inhalt, diesmal aber in die HTML-Auszeichnungen für die rote Textfarbe. Das sieht dann etwa so aus:<\/p>\n Schließlich stellen wir diesem noch ein geschütztes Leerzeichen voran.<\/p>\n Da es ja nicht nur eine Fundstelle im zu durchsuchenden Text geben kann, sondern mehrere, stellen wir nun die Position lngPosEnde <\/b>auf das Ende der Zeile mit der Fundstelle ein und suchen von dort aus nach einem weiteren Vorkommen, dessen Start wir wieder in der Variablen lngPosStart <\/b>speichern.<\/p>\n Und damit schließt sich der Kreis praktisch, denn wenn lngPosStart <\/b>dann wieder einen Wert ungleich 0 <\/b>enthält und somit eine weitere Fundstelle vorliegt, wird die Do While<\/b>-Schleife nochmals durchlaufen.<\/p>\n Zuvor allerdings ist noch eine kleine Aufgabe zu erledigen: Die Fundstelle soll nämlich noch in der Tabelle tbl-Fundstellen <\/b>gespeichert werden. Das erledigt dann eine INSERT INTO<\/b>-Anweisung, die noch vor dem Durchlaufen der Do While<\/b>-Schleife ausgeführt wird und den Inhalt von strAusschnitt <\/b>speichert.<\/p>\n Das Ergebnis sieht dann in der Tabelle tblFundstellen <\/b>wie in Bild 6 aus.<\/p>\n Bild 6: Die in der Tabelle tblFundstellen gespeicherten und farbig markierten Fundstellen<\/span><\/b><\/p>\n Dass diese Liste auch noch im Unterformular erscheint, erledigt die Prozedur cmdSuchen_Click<\/b>, die wir ja bereits weiter oben beschrieben haben.<\/p>\n Nun wollen wir in dem Textfeld im unteren Bereich des Formulars den kompletten Text des Artikels anzeigen und dabei die Fundstelle erstens markierten und zweitens in den sichtbaren Bereich holen.<\/p>\n Hier müssen wir uns wieder auf einen Kompromiss einigen: Wenn wir ein normales Textfeld verwenden, können wir durch die Einschränkung der Funktion SelStart <\/b>nur Fundstellen anzeigen, die sich in den ersten 32.767 Zeichen befinden. Das dürfte bei Benutzer früher oder später für Verwunderung sorgen. Also verwenden wir hier das TextBox<\/b>-Steuerelement der MSForms-Bibliothek, das wir im Beitrag Die MSForms-TextBox <\/b>(www.access-im-unternehmen.de\/1114<\/b>) beschreiben.<\/p>\n Der Nachteil der MSForms-TextBox ist wiederum, dass dieses keine Anzeige von Rich-Text erlaubt. Wir können also nicht die schicken roten Markierungen nutzen, die wir in der übersicht der Fundstellen einsetzen. Also wollen wir die Fundstelle, die zum jeweils angeklickten Eintrag gehören, zumindest auf herkömmliche Weise markieren, also mit dunkler Hintergrundfarbe.<\/p>\n In unserem speziellen Fall arbeiten wir mit Texten, die im Original noch HTML-Auszeichnungen enthalten, die wir für die Anzeige der Suchergebnisse zunächst entfernen und denen wir dann zum Hervorheben der Suchergebnisse eigene HTML-Auszeichnungen hinzufügen.<\/p>\n Da wir nun zur Anzeige der Fundstelle im Kontext des vollständigen Artikels nicht mehr die Möglichkeit haben, die HTML-Auszeichnung zu nutzen, müssen wir diese zunächst entfernen und dann die jeweilige Fundstelle hervorheben. Das wird insbesondere interessant, wenn ein Artikel mehrere Fundstellen aufweist. In diesem Fall haben wir nur die Möglichkeit, die Position der Fundstelle in der Liste der Suchergebnisse zu ermitteln und dann die entsprechende Position im gesamten Artikel zu suchen. Wenn das Datenblatt im oberen Bereich also etwa drei Einträge zu einem Artikel anzeigt und der Benutzer klickt den zweiten Eintrag an, dann soll das MSForms-Textfeld unten auch diesen zweiten Eintrag in den Fokus holen.<\/p>\n Dazu fügen wir der Tabelle tblFundstellen <\/b>ein Feld namens FundstelleIndex <\/b>mit dem Datentyp Zahl <\/b>hinzu. Die Prozedur TextDurchsuchen <\/b>haben wir dazu etwas angepasst – siehe Listing 3.<\/p>\n Listing 3: Anpassung der Prozedur TextDurchsuchen zum Anlegen des Indexes einer Fundstelle<\/span><\/b><\/p>\n Damit wir im Klassenmodul des Hauptformulars die Ereignisse des Unterformulars implementieren können, haben wir, wie weiter oben bereits beschrieben, dort eine Variable angelegt, welche ein Formular mit dem Schlüsselwort WithEvents <\/b>deklariert.<\/p>\n Diese wird in der Ereignisprozedur Form_Load <\/b>mit einem Verweis auf das im Unterformular-Steuerelement enthaltenen Formular gefüllt.<\/p>\n Nun wollen wir das Ereignis Beim Anzeigen <\/b>des Unterformulars im Klassenmodul des Hauptformulars implementieren, was wir wie folgt erledigen:<\/p>\n Diese Prozedur löst die Routine EintragAnzeigen <\/b>aus Listing 4 aus. Die Prozedur deklariert einige Variablen und trägt dann den Suchbegriff aus dem Textfeld txtSuchbegriff <\/b>in die Variable strSuchbegriff <\/b>ein.<\/p>\n![\"Einsatz](\"..\/fileadmin\/_temp_\/2018_01\/pic_1119_002.png\")
<\/p>\nZiel<\/h2>\n
Tabelle zum Speichern der Fundstellen<\/h2>\n
![\"Tabelle](\"..\/fileadmin\/_temp_\/2018_01\/pic_1119_003.png\")
<\/p>\nUnterformular zur Anzeige der Fundstellen<\/h2>\n
![\"Entwurf](\"..\/fileadmin\/_temp_\/2018_01\/pic_1119_004.png\")
<\/p>\nHauptformular mit der Suchfunktion<\/h2>\n
\n
![\"Entwurf](\"..\/fileadmin\/_temp_\/2018_01\/pic_1119_005.png\")
<\/p>\nSELECT BeitragID, Inhalt, TextRoh\r\nFROM tblBeitraege;<\/pre>\n
Initialisieren des Formulars<\/h2>\n
Private Sub <\/span>Form_Open(Cancel As Integer<\/span>)\r\n Dim <\/span>db As <\/span>DAO.Database\r\n Set<\/span> db = CurrentDb\r\n db.Execute \"DELETE FROM tblFundstellen\", dbFailOnError\r\nEnd Sub<\/span><\/pre>\nDim <\/span>WithEvents objFundstelle As <\/span>MSForms.TextBox<\/pre>\nPrivate Sub <\/span>Form_Load()\r\n Set<\/span> objFundstelle = Me!txtFundstelle.Object\r\n With<\/span> objFundstelle\r\n .SelectionMargin = False<\/span>\r\n .Font = \"Calibri\"\r\n .Font.Size = \"9\"\r\n .MultiLine = True<\/span>\r\n .BorderStyle = fmBorderStyleSingle\r\n .SpecialEffect = fmSpecialEffectFlat\r\n .BorderColor = Me!txtSuchbegriff.BorderColor\r\n .ScrollBars = fmScrollBarsVertical\r\n End With<\/span>\r\n Set<\/span> sfm = Me!sfmVolltextsuche.Form\r\n With<\/span> sfm\r\n .OnCurrent = \"[Event Procedure]\"\r\n End With<\/span>\r\nEnd Sub<\/span><\/pre>\nPrivate <\/span>WithEvents sfm As <\/span>Form<\/pre>\nPrivate Sub <\/span>sfm_Current()\r\n EintragAnzeigen\r\nEnd Sub<\/span><\/pre>\nFundstellen ermitteln<\/h2>\n
Private Sub <\/span>cmdSuchen_Click()\r\n Dim <\/span>db As <\/span>DAO.Database\r\n Dim <\/span>rst As <\/span>DAO.Recordset\r\n Dim <\/span>strSuche As String<\/span>\r\n If <\/span>Len<\/span>(Nz(Me!txtSuchbegriff, \"\")) = 0 Then<\/span>\r\n MsgBox<\/span> \"Bitte geben Sie einen Suchbegriff ein.\"\r\n Exit Sub<\/span>\r\n End If<\/span>\r\n strSuche = Me!txtSuchbegriff\r\n DoCmd.Hourglass True<\/span>\r\n Set<\/span> db = CurrentDb\r\n Set<\/span> rst = db.OpenRecordset(\"SELECT * FROM tblBeitraege WHERE TextRoh LIKE ''''*\" & strSuche & \"*''''\", dbOpenDynaset)\r\n db.Execute \"DELETE FROM tblFundstellen\", dbFailOnError\r\n Do While<\/span> Not<\/span> rst.EOF\r\n TextDurchsuchen rst!TextRoh, strSuche, rst!BeitragID, db\r\n rst.MoveNext<\/span>\r\n Loop<\/span>\r\n Me!sfmVolltextsuche.Form.Requery\r\n If <\/span>Not<\/span> DCount(\"*\", \"tblFundstellen\") = 0 Then<\/span>\r\n Me.Filter = \"\"\r\n EintragAnzeigen\r\n Else<\/span>\r\n Me!txtCode = Null\r\n Me.Filter = \"1=2\"\r\n End If<\/span>\r\n Me.FilterOn = True<\/span>\r\n DoCmd.Hourglass False<\/span>\r\nEnd Sub<\/span><\/pre>\nDurchsuchen eines Beitrags<\/h2>\n
Private Sub <\/span>TextDurchsuchen(strInhalt As String<\/span>, strSuche As String<\/span>, lngBeitragID As Long<\/span>, db As <\/span>DAO.Database)\r\n Dim <\/span>bolErsteZeile As Boolean<\/span>\r\n Dim <\/span>lngPosStart As Long<\/span>, lngPosEnde As Long<\/span>, lngStart As Long<\/span>, lngEnde As Long<\/span>\r\n Dim <\/span>strAusschnitt As String<\/span>, strSQL As String<\/span>\r\n bolErsteZeile = False<\/span>\r\n lngPosStart = InStr<\/span>(1, strInhalt, strSuche)\r\n Do While<\/span> Not<\/span> lngPosStart = 0\r\n lngStart = InStrRev<\/span>(strInhalt, vbCrLf<\/span>, lngPosStart)\r\n If <\/span>lngStart = 0 Then<\/span>\r\n lngStart = 1\r\n bolErsteZeile = True<\/span>\r\n Else<\/span>\r\n bolErsteZeile = False<\/span>\r\n End If<\/span>\r\n lngStart = InStrRev<\/span>(strInhalt, vbCrLf<\/span>, lngStart)\r\n If <\/span>lngStart = 0 Then<\/span> bolErsteZeile = True<\/span>\r\n lngEnde = InStr<\/span>(lngPosStart, strInhalt, vbCrLf<\/span>)\r\n lngEnde = InStr<\/span>(lngEnde + 2, strInhalt, vbCrLf<\/span>)\r\n If <\/span>lngEnde = 0 Then<\/span>\r\n lngEnde = Len<\/span>(strInhalt)\r\n End If<\/span>\r\n If <\/span>Not<\/span> bolErsteZeile Then<\/span>\r\n If <\/span>lngEnde > lngStart Then<\/span>\r\n strAusschnitt = Mid<\/span>(strInhalt, lngStart + 2, lngEnde - lngStart - 2)\r\n Else<\/span>\r\n strAusschnitt = Mid<\/span>(strInhalt, lngStart + 2)\r\n End If<\/span>\r\n Else<\/span>\r\n strAusschnitt = Mid<\/span>(strInhalt, lngStart + 1, lngEnde - lngStart - 1)\r\n End If<\/span>\r\n strAusschnitt = Replace<\/span>(strAusschnitt, \"<\", \"<\")\r\n strAusschnitt = Replace<\/span>(strAusschnitt, \">\", \">\")\r\n strAusschnitt = Replace<\/span>(strAusschnitt, strSuche, \"<font color=red>\" & Mid<\/span>(strInhalt, lngPosStart, _\r\n Len<\/span>(strSuche)) & \"<\/font>\")\r\n strAusschnitt = Replace<\/span>(strAusschnitt, \" <font\", \" <font\")\r\n lngPosEnde = InStr<\/span>(lngPosStart + 1, strInhalt, vbCrLf<\/span>)\r\n If <\/span>lngPosEnde = 0 Then<\/span>\r\n lngPosEnde = Len<\/span>(strInhalt)\r\n End If<\/span>\r\n If <\/span>Not<\/span> bolErsteZeile Then<\/span>\r\n lngPosStart = InStr<\/span>(lngPosEnde + 1, strInhalt, strSuche)\r\n Else<\/span>\r\n lngPosStart = InStr<\/span>(lngPosEnde + 1, strInhalt, strSuche) '''' + 1\r\n End If<\/span>\r\n strSQL = \"INSERT INTO tblFundstellen(BeitragID, Fundstelle) VALUES(\" & lngBeitragID & \", ''''\" _\r\n & Replace<\/span>(Replace<\/span>(Replace<\/span>(strAusschnitt, \"''''\", \"''''''''\"), vbCrLf<\/span>, \"<br>\"), \"\"\"\", \"\"\"\"\"\") & \"'''')\"\r\n db.Execute strSQL, dbFailOnError\r\n Loop<\/span>\r\nEnd Sub<\/span><\/pre>\nMarkierung hinzufügen<\/h2>\n
<font color=red>...<\/font><\/pre>\n
![\"Die](\"..\/fileadmin\/_temp_\/2018_01\/pic_1119_006.png\")
<\/p>\nFundstelle im Kontext anzeigen<\/h2>\n
Private Sub <\/span>TextDurchsuchen(...)\r\n ...\r\n Dim <\/span>intFundstelleIndex As Integer<\/span>\r\n ...\r\n Do While<\/span> Not<\/span> lngPosStart = 0\r\n intFundstelleIndex = intFundstelleIndex + 1\r\n ...\r\n strSQL = \"INSERT INTO tblFundstellen(BeitragID, Fundstelle, FundstelleIndex) VALUES(\" & lngBeitragID & \", ''''\" _\r\n & Replace<\/span>(Replace<\/span>(Replace<\/span>(strAusschnitt, \"''''\", \"''''''''\"), vbCrLf<\/span>, \"<br>\"), \"\"\"\", \"\"\"\"\"\") & \"'''', \" _\r\n & intFundstelleIndex & \")\"\r\n db.Execute strSQL, dbFailOnError\r\n Loop<\/span>\r\nEnd Sub<\/span><\/pre>\nAuf Ereignisse im Unterformular reagieren<\/h2>\n
Private Sub <\/span>sfm_Current()\r\n EintragAnzeigen\r\nEnd Sub<\/span><\/pre>\nPrivate Sub <\/span>EintragAnzeigen()\r\n Dim <\/span>strInhalt As String<\/span>\r\n Dim <\/span>strSuchbegriff As String<\/span>\r\n Dim <\/span>lngPosStart As Long<\/span>\r\n Dim <\/span>lngLen As Long<\/span>\r\n Dim <\/span>intIndex As Integer<\/span>\r\n Dim <\/span>i As Integer<\/span>\r\n Dim <\/span>lngCurLine As Long<\/span>\r\n strSuche = Nz(Me!txtSuchbegriff)\r\n intIndex = Me!sfmVolltextsuche.Form!FundstelleIndex\r\n Me.Recordset.FindFirst \"BeitragID = \" & Me!sfmVolltextsuche.Form!BeitragID\r\n strInhalt = Nz(Me!TextRoh)\r\n strInhalt = Replace<\/span>(strInhalt, \"<b>\", \"\")\r\n strInhalt = Replace<\/span>(strInhalt, \"<\/b>\", \"\")\r\n Me!txtFundstelle = strInhalt\r\n strSuchbegriff = Me!txtSuchbegriff\r\n lngLen<\/span> = Len<\/span>(strSuchbegriff)\r\n lngPosStart = InStr<\/span>(1, strInhalt, strSuchbegriff)\r\n For i = 2 To intIndex\r\n lngPosStart = InStr<\/span>(lngPosStart + lngLen, strInhalt, strSuchbegriff)\r\n Next<\/span> i\r\n With<\/span> objFundstelle\r\n .CurLine = 0\r\n .SelStart = lngPosStart\r\n .SelLength = lngLen\r\n lngCurLine = .CurLine\r\n .CurLine = lngCurLine + 5\r\n Me!txtFundstelle.SetFocus\r\n .SelStart = lngPosStart\r\n .SelLength = lngLen\r\n End With<\/span>\r\nEnd Sub<\/span><\/pre>\n