Der Dialog zum Suchen und Ersetzen für die Suche nach Daten in der Datenblattansicht ist bereits sehr praktisch. Allerdings hatte ein Leser die Anforderung, dass er öfter mit dem Dialog nach den gleichen Ausdrücken sucht, um diese zu ersetzen. Der Dialog hat zwar immer die zuletzt verwendeten zu suchenden und zu ersetzenden Ausdrücke gespeichert und in den Auswahlfeldern angeboten, aber wenn er die Datenbank geschlossen und erneut geöffnet hat, war die Arbeit verloren und die Auswahlfelder waren wieder leer. Also bauen wir diesen Dialog einfach nach und erweitern diesen um eine Funktion, welche die zuletzt verwendeten Einträge dauerhaft speichert und diese nach dem Schließen und Öffnen der Anwendung wieder bereitstellt.<\/b><\/p>\n
Worum geht es?<\/h2>\n
Der Suchen und Ersetzen-Dialog, den wir durch einen besseren Dialog ersetzen wollen, kann über den Ribbon-Eintrag Start|Suchen|Suchen <\/b>geöffnet werden (siehe Bild 1).<\/p>\n
![\"Aufruf](\"..\/fileadmin\/_temp_\/2025_04\/pic_1560_003.png\")
<\/p>\n
Bild 1: Aufruf des Suchen und Ersetzen-Dialogs<\/span><\/b><\/p>\n Dies öffnet den Dialog mit aktiviertem Suchen<\/b>-Registerreiter (siehe Bild 2). Hier können wir nacheinander nach verschiedenen Begriffen suchen. Die zuletzt verwendeten Begriffe werden beim Aufklappen der Auswahl unter Suchen nach: <\/b>direkt bereitgestellt.<\/p>\n Bild 2: Der Suchen und Ersetzen-Dialog<\/span><\/b><\/p>\n Wir können direkt von diesem Dialog aus zur Registerseite Ersetzen <\/b>wechseln. Diese enthält lediglich einige zusätzliche Elemente wie zum Beispiel das Feld zum Eingeben des zu ersetzenden Ausdrucks (siehe Bild 3). Außerdem finden wir nun Schaltfläche zum Ersetzen der aktuellen Fundstelle und aller Fundstellen.<\/p>\n Bild 3: Registerseite Ersetzen des Suchen und Ersetzen-Dialogs<\/span><\/b><\/p>\n Der Dialog kann außerdem mit der Taste Strg + F <\/b>geöffnet werden.<\/p>\n Der Dialog erlaubt mit Suchen in <\/b>das Festlegen des Suchziels:<\/p>\n Mit Vergleichen <\/b>können wir angeben, welcher Teil der Felder untersucht werden soll: Teil des Feldinhalts<\/b>, Ganzes Feld <\/b>oder Anfang des Feldinhalts<\/b>.<\/p>\n Unter Suchen <\/b>geben wir an, welchen Bereich wir ausgehend vom aktuell markierten Steuerelement untersuchen wollen:<\/p>\n Mit Groß-\/Kleinschreibung <\/b>können wir angeben, ob wir Groß- und Kleinschreibung berücksichtigen wollen.<\/p>\n Schließlich gibt es noch die Option Formatierung beachten<\/b>. Diese ist zum Beispiel bei Datumsfeldern wichtig, wenn man eine andere Formatierung angegeben hat als das System verwendet. Wenn wir also Datumsangaben eigentlich im Format tt.mm.jjjj <\/b>speichern (zum Beispiel 21.06.2025<\/b>), aber für das Tabellenfeld das Format tt-mm-jjjj <\/b>festgelegt haben, wird das Datum als 21-06-2025 <\/b>angezeigt.<\/p>\n Eine Suche nach 21.06. <\/b>liefert nun in jedem Fall das gesuchte Datum. Wenn wir jedoch nach 21-06- <\/b>suchen und Formatierung beachten <\/b>ist deaktiviert, finden wir das Datum nicht.<\/p>\n Erst wenn wir Formatierung beachten aktivieren, liefert auch 21-06-<\/b> das gewünschte Ergebnis.<\/p>\n Mit der Schaltfläche Weitersuchen <\/b>starten wir den Suchvorgang nach dem nächsten Vorkommen. Klicken wir diese wiederholt an, durchläuft Access alle Fundstellen.<\/p>\n Diese Schaltfläche funktioniert nur, wenn zuvor mit Weitersuchen <\/b>eine Fundstelle markiert wurde. Das Anklicken führt dann zur gewünschten Ersetzung und markiert automatisch die nächste Fundstelle, sofern noch ein weiteres Vorkommen vorhanden ist.<\/p>\n So können wir durch wiederholtes Betätigen dieser Schaltfläche alle Vorkommen des gesuchten Begriffes ersetzen.<\/p>\n Diese Schaltfläche ersetzt automatisch alle Vorkommen im angegebenen Bereich. Dazu muss nicht zuvor ein Vorkommen markiert worden sein.<\/p>\n Bevor wir Zeit investieren, den Suchen und Ersetzen<\/b>-Dialog original nachzubilden und diesen um die gewünschten Funktionen zu erweitern, wollen wir erst einmal prüfen, ob sich das grundlegende Verhalten überhaupt reproduzieren lässt.<\/p>\n Um per VBA-Code zum Beispiel nach bestimmten Inhalten im Datenblatt zu suchen, müssen wir das Recordset des Datenblatts referenzieren. Die Frage lautet: Gelingt das überhaupt per Code? Haben jegliche Datenblätter ein Recordset, auf das wir zugreifen können – egal, ob es die Datenblattansicht einer Tabelle, einer Abfrage oder auch eines Formulars ist? Beim Formular wissen wir, dass wir auf das Recordset der Datenblattansicht zugreifen können.<\/p>\n Hier referenzieren wir das Formular über die Forms<\/b>-Auflistung und greifen dann über die Recordset<\/b>-Eigenschaft auf das Recordset zu. Aber wie soll das mit Tabellen und Abfragen funktionieren? Immerhin gibt es keine Table<\/b>– oder Query<\/b>-Auflistungen, die wir analog zur Forms<\/b>-Auflistung nutzen könnten.<\/p>\n Aber benötigen wir überhaupt eine Auflistung, um auf das aktuelle Objekt und sein Recordset zugreifen zu können?<\/p>\n Schnelle Experimente zeigen: Nein, das ist nicht der Fall. Wie können nämlich die Elemente der Screen<\/b>-Klasse nutzen.<\/p>\n Wir schauen uns dies zuerst anhand einer Tabelle an, die wir in der Datenblattansicht geöffnet haben.<\/p>\n Öffnen wir parallel dazu den Direktbereich des VBA-Editors und geben dort den Ausdruck Screen.ActiveDatasheet.Name <\/b>ein, erhalten wir tatsächlich den Namen des aktuellen Datenblatts respektive der zugrunde liegenden Tabelle (siehe Bild 4).<\/p>\n Bild 4: Zugriff per VBA auf das aktuelle Datenblatt einer Tabelle<\/span><\/b><\/p>\n Also probieren wir auch gleich aus, ob wir damit auch auf ein entsprechendes Recordset<\/b>-Objekt zugreifen können. Auch das gelingt:<\/p>\n Das Gleiche funktioniert auch, wenn wir eine Abfrage in der Datenblattansicht öffnen.<\/p>\n Bei Formularen müssen wir differenzieren. Wir können hier Formular vorfinden, die ihre Daten direkt in der Datenblattansicht anzeigen oder solche, die Unterformulare für die Datenblattansicht verwenden.<\/p>\n Bei Formularen, die ihre Daten direkt in der Datenblattansicht anzeigen, können wir ebenfalls mit Screen.ActiveDatasheet <\/b>arbeiten.<\/p>\n Bei Formularen, die ein Unterformular in der Datenblattansicht anzeigen, gelingt dies nicht so einfach, wie Bild 5 zeigt. Hier erhalten wir eine Fehlermeldung.<\/p>\n Bild 5: Fehler beim Zugriff per VBA auf das aktuelle Datenblatt im Unterformular<\/span><\/b><\/p>\n Wir können auch nicht mit der folgenden Anweisung darauf zugreifen – hier erhalten wir lediglich das Hauptformular:<\/p>\n Wenn sich der Fokus jedoch in einem der Steuerelemente im Unterformular befindet, können wir am einfachsten über folgenden Ausdruck darauf zugreifen:<\/p>\n Allerdings funktioniert die Originalfunktion nicht nur in Datenblättern, sondern eigentlich in allen Formularen, die überhaupt mindestens ein Steuerelement enthalten, das durchsuchbar ist – also zum Beispiel ein Textfeld. Wir wollen in diesem Beispiel allerdings nur eine Suchen und Ersetzen<\/b>-Funktion für Datenblätter erstellen.<\/p>\n Wenn wir schon dabei sind, den Suchen und Ersetzen<\/b>-Dialog zu verbessern, können wir auch gleich noch weitere Ergänzungen hinzufügen.<\/p>\n Zum Beispiel könnten wir den Dialog so programmieren, dass er beim Öffnen gleich den Wert im Suchen<\/b>-Feld anzeigt, der im aktuellen Steuerelement mit dem Fokus enthalten ist – vorausgesetzt, dieses Feld enthält einen Wert beziehungsweise kann einen Wert enthalten.<\/p>\n Beim Ersetzen von Werten benötigen wir ein wenig mehr Code. Wir müssen aus den Parametern des Dialogs eine kleine Prozedur erstellen, die eine UPDATE<\/b>-Anweisung zusammenbaut und ausführt. Dies schauen wir uns später im Detail an.<\/p>\n Nachdem die technischen Voraussetzungen geklärt sind, bauen wir das Suchen und Ersetzen<\/b>-Formular originalgetreu nach.<\/p>\n Dazu erstellen wir ein neues, leeres Formular und speichern es unter dem Namen frmSuchenUndErsetzen<\/b>. Um es später vom eingebauten Suchen<\/b>-Dialog unterscheiden zu können, tragen wir für Beschriftung den Text Suchen und Ersetzen PRO <\/b>ein.<\/p>\n Dann fügen wir erst einmal die Steuerelemente hinzu und legen ihre Namen fest.<\/p>\n Wichtig: Wir fügen kein echtes Registersteuerelement hinzu, denn eigentlich benötigen wir kein Registersteuerelement.<\/p>\n Wir haben nicht geprüft, ob Microsoft für den Suchen und Ersetzen<\/b>-Dialog tatsächlich ein Registersteuerelement verwendet und ob dort die auf beiden Registerseiten vorkommenden Steuerelemente jeweils zwei Mal angelegt wurden. Wir werden das jedenfalls nicht tun und stattdessen ein Fake-Registersteuerelement bauen.<\/p>\n Dazu verwenden wir ein weißes Rechteck und zwei Schaltflächen, die wir über diesem Rechteck platzieren – genau so, dass der untere Rand der Schaltflächen etwas unter dem Rechteck verschwindet. Dazu müssen wir zuerst die Schaltflächen anlegen und dann das Rechteck-Steuerelement. In der Z-Reihenfolge werden immer die zuletzt angelegten Steuerelemente über die übrigen gelegt.<\/p>\n Dementsprechend fügen wir auch die übrigen Steuerelemente erst hinzu, wenn wir das Rechteck angelegt haben, und ordnen diese wie in Bild 6 an.<\/p>\n Bild 6: Entwurf des neuen Suchen und Ersetzen-Dialogs<\/span><\/b><\/p>\n Die Steuerelemente versehen wir mit den folgenden Namen:<\/p>\n Für die Schaltflächen fügen wir passende Icons hinzu, indem wir die jeweilige Schaltfläche markieren und dann den Ribbonbefehl Formularentwurf|Steuerlemente|Bild einfügen <\/b>nutzen.<\/p>\n Den Hintergrund <\/b>der Schaltflächen stellen wir auf Transparent <\/b>ein, die Anordnung der Bildbeschriftung <\/b>auf Rechts <\/b>und die Schriftbreite <\/b>für alle außer der nicht markierten Registerschaltfläche auf Fett<\/b>.<\/p>\n Außerdem fügen wir vor der Eigenschaft Beschriftung <\/b>der Schaltflächen jeweils zwei Leerzeichen ein, damit die Beschriftung nicht zu nah an den Icons erscheint.<\/p>\n Da das Formular selbst keine Datensatzquelle hat, stellen wir die Eigenschaften Datensatzmarkierer<\/b>, Navigationsschaltflächen <\/b>und Bildlaufleisten <\/b>auf Nein <\/b>und Automatisch zentrieren <\/b>auf Ja <\/b>ein.<\/p>\n Die beiden Kombinationsfelder Suchen nach und Ersetzen durch sollen die bisher eingegebenen Texte anzeigen.<\/p>\n Damit der Benutzer auch mal einen der eingegebenen Texte entfernen kann, wollen wir außerdem noch zwei Schaltflächen zum Löschen des aktuell ausgewählten Eintrags hinzufügen.<\/p>\n Diese erhalten die Namen cmdSuchenNachLoeschen <\/b>und cmdErsetzenDurchLoeschen<\/b>. Danach sieht der Entwurf wie in Bild 7 aus. Die Funktionalität dieser Schaltflächen fügen wir später hinzu.<\/p>\n Bild 7: Schaltflächen zum Leeren<\/span><\/b><\/p>\n Wenn der Benutzer die Eingabetaste betätigt, soll die Schaltfläche cmdWeitersuchen <\/b>ausgelöst werden. Dazu stellen wir die Eigenschaft Standard <\/b>für diese Schaltfläche auf Ja <\/b>ein.<\/p>\n Leider funktioniert das nicht, wenn der Fokus auf einer der übrigen Schaltflächen liegt. Dann wird die jeweils aktive Schaltfläche ausgeführt. Also müssen wir für die übrigen Tasten noch das Ereignis Bei Taste Ab <\/b>definieren und hier prüfen, ob der Benutzer für diese die Eingabetaste betätigt hat. Ist das der Fall, soll die Ereignisprozedur der Schaltfläche cmdWeitersuchen <\/b>ausgelöst werden. Dazu hinterlegen wir zunächst die entsprechende Ereignisprozedur, die wir allerdings erst einmal mit einer Dummy-Meldung füllen:<\/p>\n Für die übrigen Schaltflächen legen wir nun jeweils eine Prozedur für das Ereignis Bei Taste Ab <\/b>an, die wir wie folgt füllen:<\/p>\n Damit führt das Betätigen der Eingabetaste nun immer die Taste cmdWeitersuchen <\/b>aus.<\/p>\n Betätigt der Benutzer die Escape<\/b>-Taste, soll der Suchen und Ersetzen<\/b>-Dialog geschlossen werden. Dazu stellen wir die Eigenschaft Abbrechen <\/b>für diese Schaltfläche auf Ja <\/b>ein.<\/p>\n Die Ereignisprozedur für diese Schaltfläche können wir gleich anlegen. Sie lautet:<\/p>\n Nun füllen wir die Kombinationsfelder, zunächst die drei unteren – diese nehmen jeweils eine Wertliste auf.<\/p>\n Das Kombinationsfeld cboSuchenIn <\/b>erhalt diese Werteliste:<\/p>\n Damit diese angezeigt wird, stellen wir außerdem die Eigenschaft Herkunftsart <\/b>auf Wertliste <\/b>ein. Außerdem wollen wir verhindern, dass der Benutzer die Wertliste bearbeiten kann und legen daher noch den Wert Nein <\/b>für die Eigenschaft Wertlistenbearbeitung zulassen <\/b>fest (siehe Bild 8).<\/p>\n Bild 8: Einstellen der Werte für die Kombinationsfelder<\/span><\/b><\/p>\n Die Einstellungen für die weiteren beiden Kombinationsfelder sind weitgehend identisch. Lediglich die Datensatzherkünfte unterscheiden sich. Die für das Kombinationsfeld cboVergleichen <\/b>lautet:<\/p>\n Und für cboSuchen <\/b>verwenden wir:<\/p>\n Schließlich wollen wir noch dafür sorgen, dass alle drei Kombinationsfelder jeweils den ersten Eintrag bei Öffnen des Formulars anzeigen. Außerdem soll die Schaltfläche cmdWeitersuchen <\/b>immer direkt den Fokus erhalten. Dazu fügen wir dem Formular eine Ereignisprozedur für das Ereignis Beim Laden <\/b>hinzu, die wie folgt aussieht:<\/p>\n Damit erhalten wir nun das Zwischenergebnis aus Bild 9.<\/p>\n Bild 9: Kombinationsfeld in Aktion<\/span><\/b><\/p>\n Hier sehen wir allerdings, dass trotz der Aktivierung der Schaltfläche für die Registerseite Suchen <\/b>auch die Steuerelemente angezeigt werden, die erst für die Registerseite Ersetzen <\/b>eingeblendet werden sollen. Das ändern wir durch jeweils eine Ereignisprozedur für die beiden Registerschaltflächen.<\/p>\n Klickt der Benutzer auf regErsetzen<\/b>, sollen das Kombinationsfeld cboErsetzen <\/b>und die beiden Schaltflächen cmdErsetzen <\/b>und cmdAlleErsetzen <\/b>eingeblendet werden. Außerdem soll die Schrift der Schaltfläche regSuchen <\/b>nicht mehr fett dargestellt werden, dafür aber die der Schaltfläche cmdErsetzen<\/b>.<\/p>\n Und schließlich wird der Wert des Feldes Ersetzen <\/b>der zugrunde liegenden Tabelle tblSuchenUndErsetzen <\/b>auf True <\/b>eingestellt, damit dieser Zustand später wiederhergestellt werden kann:<\/p>\n Die Schaltfläche regSuchen <\/b>soll den umgekehrten Effekt bewirken:<\/p>\n Wir müssen außerdem noch dafür sorgen, dass das Kombinationsfeld cboErsetzen <\/b>sowie die beiden Schaltflächen cmdErsetzen <\/b>und cmdAlleErsetzen <\/b>zunächst ausgeblendet sind – das erledigen wir durch Einstellen der entsprechenden Eigenschaften im Eigenschaftenblatt.<\/p>\n Standardmäßig öffnet das Formular nun im Modus Suchen<\/b>. Da wir das Formular jedoch auch direkt zum Ersetzen öffnen wollen, fügen wir dem Ereignis Beim Öffnen <\/b>noch die Abfrage nach dem Öffnungsargument hinzu. Lautet dies Ersetzen<\/b>, soll das Formular direkt für das Ersetzen vorbereitet werden.<\/p>\n Zunächst einmal soll das Öffnen des Formulars für diesen Modus so erfolgen:<\/p>\n In der Ereignisprozedur, die wir für das Ereignis Beim Öffnen <\/b>aufrufen, fügen wir nun diese Anweisungen hinzu:<\/p>\n Damit wird die Prozedur regErsetzen_Click <\/b>aufgerufen, wenn als Öffnungsparameter Ersetzen <\/b>übergeben wurde.<\/p>\n Nach dem Öffnen im Suchen-Modus sieht das Formular nun wie in Bild 10 aus.<\/p>\n Bild 10: Formular nach dem Öffnen im Suchen-Modus<\/span><\/b><\/p>\n Der eigentliche Clou des neuen Suchen und Ersetzen-Formulars soll das Speichern der verwendeten Einträge für die Kombinationsfelder Suchen nach <\/b>und Ersetzen durch <\/b>sein. Hier stellt sich die Frage, wo wir diese Einträge speichern sollen. Wir könnten das in einer oder mehreren Tabellen oder in der Registry erledigen.<\/p>\n Praktischer wären Tabellen, da wir hier die Daten direkt nach den gewünschten Kriterien sortieren könnten.<\/p>\n Das wir den neuen Suchen und Ersetzen<\/b>-Dialog ohnehin in allen Datenbanken zur Verfügung stellen wollen und nicht nur in der Datenbank, in der wir diesen programmieren, werden wir die Datenbank früher oder später in eine Add-In-Datenbank umwandeln. Also können wir hier auch alle notwendigen Tabellen integrieren – die Daten stehen dann in allen Anwendungen zur Verfügung, von denen aus wir den Suchen und Ersetzen<\/b>-Dialog aufrufen.<\/p>\n Stellt sich also die Frage, welche Daten wir wie speichern wollen. Zunächst benötigen wir in jedem Fall jeweils eine Tabelle für die Begriffe aus den beiden Kombinationsfeldern Suchen nach <\/b>und Ersetzen durch<\/b>. Es kann jedoch auch sinnvoll sein, die übrigen Einstellungen zu speichern – also zum Beispiel den aktuell ausgewählten Wert der Auswahlfelder Suchen in<\/b>, Vergleichen <\/b>und Suchen <\/b>sowie die Daten der beiden Kontrollkästchen.<\/p>\n Die erste Tabelle heißt tblSuchenNach <\/b>und nimmt im Feld Suchen <\/b>alle Begriffe auf, die wir in das Feld cboSuchenNach <\/b>eingeben. Außerdem fügen wir ein Feld namens KonfigurationID<\/b> hinzu, mit der wir die aktuelle Konfiguration festlegen.<\/p>\n Diese speichert die weiteren Eigenschaften und die Datenbank, für welche wir diese Eigenschaften definiert haben. Schließlich legen wir noch ein Feld namens ErsetzenDurchID <\/b>an. Wichtig: Der Standardwert dieses Feldes muss leer sein.<\/p>\n Das Feld verknüpfen wir später mit dem Primärschlüsselfeld der nachfolgend angelegten Tabelle tblErsetzenDurch<\/b>, damit wir zu dem zuletzt verwendeten Suchbegriff auch noch den eventuell angegebenen Ersetzungstext speichern können.<\/p>\n Für diese Tabelle legen wir neben dem Primärschlüssel noch einen weiteren Index fest, der sich aus den beiden Feldern SuchenNach <\/b>und KonfigurationID <\/b>zusammensetzt und für den wir die Eigenschaft Eindeutig <\/b>auf Ja <\/b>einstellen. Damit stellen wir sicher, dass jeder Suchbegriff nur einmal pro Konfiguration gespeichert wird (siehe Bild 11).<\/p>\n Bild 11: Tabelle zum Speichern der Suchbegriffe<\/span><\/b><\/p>\n Die zweite Tabelle namens tblErsetzenDurch <\/b>bauen wir analog auf (siehe Bild 12). Hiermit können wir direkt die letzte Ersetzung, die wir einem Suchbegriff zugeordnet haben, ermitteln und bei Auswahl des Suchbegriffs wieder auswählen. Hier wird die Definition eines eindeutigen Indexes zur Begrenzung der Ersetzungstexte etwas komplizierter. <\/p>\n Bild 12: Tabelle zum Speichern der Inhalte zum Ersetzen<\/span><\/b><\/p>\n Schließlich fehlt noch die Tabelle tblSuchenUndErsetzen<\/b>, welche die Konfigurationen speichert (siehe Bild 13).<\/p>\n Bild 13: Tabelle zum Speichern der Konfigurationen<\/span><\/b><\/p>\n An dieser Stelle müssen wir uns entscheiden, ob wir nur eine Konfiguration je Datenbank zulassen wollen oder ob wir dem Benutzer die Gelegenheit geben wollen, gleich mehrere Konfigurationen je Datenbank zu speichern. Wir entscheiden uns an dieser Stelle dafür, dass wir je Objekt, für welches der Suchen und Ersetzen<\/b>-Dialog aufgerufen wird, jeweils eine Konfiguration zu speichern. Deshalb fügen wir der Tabelle auch ein Feld namens Objektname <\/b>hinzu.<\/p>\n Womit wollen wir diese füllen? Wir ermitteln einfach entweder über Screen.ActiveDataSheet.Name<\/b> den Objektnamen der Datenblattansicht oder, wenn dies einen Fehler liefert, den Namen des Formulars, für das der Suchen und Ersetzen<\/b>-Dialog aufgerufen wurde – mehr dazu später.<\/p>\n In den beiden Feldern SuchenNach <\/b>und ErsetzenDurch <\/b>speichern wir die zuletzt verwendeten Werte für diese beiden Eigenschaften.<\/p>\n Die folgenden fünf Felder der Tabelle tblSuchenUndErsetzen <\/b>nehmen die verwendeten Werte für die drei weiteren Kombinationsfelder und die Kontrollkästchen auf.<\/p>\n Danach folgt noch das Feld Datenbankname<\/b>. Hier gehen wir davon aus, dass dieser konstant bleibt. Wenn der Benutzer den Datenbanknamen ändert, wird dazu keine Konfiguration mehr gefunden.<\/p>\n Und schließlich legen wir noch ein Ja\/Nein<\/b>-Feld namens Ersetzen <\/b>an, mit dem wir speichern, ob der Benutzer zuletzt die Registerseite Suchen <\/b>oder Ersetzen <\/b>geöffnet hatte.<\/p>\n Auch für diese Tabelle erstellen wir einen zusammengesetzten, eindeutigen Index, mit dem wir sicherstellen, dass für jede Kombination aus Datenbank <\/b>und Objektname <\/b>nur eine Konfiguration gespeichert wird.<\/p>\n Schließlich legen wir noch die Beziehungen aus Bild 14 zwischen den Tabellen an, jeweils mit referenzieller Integrität und Löschweitergabe.<\/p>\n Bild 14: Beziehungen zwischen den Tabellen<\/span><\/b><\/p>\n Damit kommen wir endlich zum technischen Teil: Wie laden und speichern wir die Konfigurationen? Hier haben wir folgende Zeitpunkte definiert:<\/p>\n Damit überhaupt Daten aus den Tabellen in den Steuerelementen des Formulars angezeigt werden, haben wir zwei Möglichkeiten. Entweder wir binden wir das Formular an die Tabellen und auch die beiden Kombinationsfelder cboSuchenNach <\/b>und cboErsetzenDurch<\/b>. Oder wir füllen die entsprechenden Werte zur Laufzeit und speichern diese zu den oben angegebenen Zeitpunkten ab.<\/p>\n Wir binden das Formular an die Tabelle tblSuchenUndErsetzen<\/b> und stellen die Steuerelementinhalt<\/b>-Eigenschaften auf die entsprechenden Felder dieser Datensatzquelle ein (siehe Bild 15).<\/p>\n Bild 15: Zuweisen der Felder zur Eigenschaft Steuerelementinhalt<\/span><\/b><\/p>\n Gleiches erledigen wir für die beiden Kombinationsfelder cboSuchenNach <\/b>und cboErsetzenDurch<\/b>. Hier legen wir für die Eigenschaft Datensatzherkunft <\/b>die Tabellen tblSuchenNach <\/b>und tblErsetzenDurch <\/b>fest. Außerdem stellen wir die Eigenschaft Spaltenanzahl <\/b>jeweils auf 2 <\/b>und die Eigenschaft Spaltenbreiten <\/b>auf 0cm <\/b>ein, damit der Primärschüsselwert der Tabelle jeweils ausgeblendet und nur der eigentliche Such- beziehungsweise Ersetzungstext angezeigt wird.<\/p>\n Die Konfigurationen hängen, wie oben beschrieben, vom Datenbanknamen und von der Bezeichnung der Datenblattansicht ab, für welche der Suchen und Ersetzen<\/b>-Dialog geöffnet wird.<\/p>\n Also müssen wir erst einmal diese beiden Informationen ermitteln. Den Datenbanknamen können wir ganz einfach über CurrentProject.Name <\/b>ermitteln.<\/p>\n Für den Namen des aktuellen Objekts benötigen wir ein paar Zeilen Code mehr.<\/p>\n Die Prozedur AktuelleDatenblattansicht <\/b>aus Listing 1 ermittelt den Namen des Objekts, das aktuell den Fokus hat – aber nur, wenn es sich in der Datenblattansicht befindet.<\/p>\n Listing 1: Ermitteln des aktuellen Objekts in der Datenblattansicht<\/span><\/b><\/p>\n Sie deaktiviert die eingebaute Fehlerbehandlung und versucht, mit Screen.ActiveDatasheet.Name <\/b>auf den Namen der Datenblattansicht des aktuell im Fokus befindlichen Objekts zuzugreifen. Das gelingt nur bei Tabellen oder Abfragen, die aktuell in der Datenblattansicht angezeigt werden.<\/p>\n Ist strObjektname <\/b>danach nicht gefüllt, können wir davon ausgehen, das ein anderes Objekt wie ein Formular den Fokus hat. Dann gehen wir davon aus, das eines der Steuerelemente dieses Formulars aktiviert ist und versuchen, über die Parent<\/b>-Eigenschaft auf das übergeordnete Element zuzugreifen – wieder bei deaktivierter Fehlerbehandlung.<\/p>\n Für dieses Element prüfen wir, ob es in der Datenblattansicht angezeigt wird. Dazu nutzen wir die CurrentView<\/b>-Eigenschaft, die wir mit dem Wert acCurViewDatasheet <\/b>vergleichen.<\/p>\n Ist diese Bedingung erfüllt, schreiben wir den Namen des Parent<\/b>-Objekts in die Variable strObjektname<\/b>.<\/p>\n Nach dem Durchlaufen dieser Anweisungen ist strObjektname <\/b>entweder gefüllt oder, wenn aktuell keine Datenblattansicht den Fokus hat, noch leer. Wenn es nicht leer ist, geben wir den Wert als Funktionsergebnis zurück.<\/p>\n Wir gehen erst einmal davon aus, dass wir den Dialog zu Testzwecken über einen Doppelklick auf das Element im Navigationsbereich öffnen. Wenn der Dialog erscheint und wir dann beispielsweise auf die zu untersuchende Datenblattansicht klicken, verschwindet der Dialog möglicherweise hinter dieser nun aktivierten Ansicht. Um das zu verhindern, stellen wir die Eigenschaft Popup <\/b>des Formulars frmSuchenErsetzen <\/b>auf Ja <\/b>ein.<\/p>\n Um zu verhindern, dass der Benutzer durch Durchlaufen aller Steuerelemente mit der Tabulator-Taste zu einem neuen, leeren Datensatz gelangt, stellen wir außerdem die Eigenschaft Zyklus <\/b>auf Aktueller Datensatz <\/b>ein.<\/p>\n Wenn wir das Formular öffnen, wird als Erstes das Ereignis Beim Öffnen <\/b>ausgelöst (siehe Listing 2).<\/p>\n Listing 2: Prozedur beim Öffnen des Formulars<\/span><\/b><\/p>\n Dieses ermittelt mit der Funktion AktuelleDatenblattansicht <\/b>den Namen der aktuell geöffneten und im Fokus befindlichen Datenblattansicht. Hat aktuell keine Datenblattansicht den Fokus, liefert die Funktion eine leere Zeichenkette. Dann erscheint eine Meldung, die den Benutzer darauf hinweis, dass der Suchen und Ersetzen<\/b>-Dialog nur für Datenblattansichten funktioniert. Durch Einstellen des Parameters Cancel <\/b>auf den Wert True <\/b>und Beenden der Prozedur wird das Formular nun gar nicht erst geöffnet.<\/p>\n Außerdem stellt die Prozedur den Wert der folgenden Variablen auf True <\/b>ein, wenn als Öffnungsargument Ersetzen <\/b>übergeben wurde:<\/p>\n Dieser Wert wird gleich im Ereignis Beim Laden <\/b>weiterverarbeitet.<\/p>\n Im Ereignis Beim Laden <\/b>des Formulars hinterlegen wir einige weitere wichtige Funktionen (siehe Listing 3). Das Formular frmSuchenErsetzen <\/b>zeigt standardmäßig ungefiltert die Daten der Tabelle Tabelle tblSuchenUndErsetzen <\/b>an.<\/p>\n![\"Der](\"..\/fileadmin\/_temp_\/2025_04\/pic_1560_004.png\")
<\/p>\n![\"Registerseite](\"..\/fileadmin\/_temp_\/2025_04\/pic_1560_005.png\")
<\/p>\nOption „Suchen in“<\/h2>\n
\n
Option „Vergleichen“<\/h2>\n
Option „Suchen“<\/h2>\n
\n
Option „Groß-\/Kleinschreibung“<\/h2>\n
Option „Formatierung beachten“<\/h2>\n
Schaltfläche „Weitersuchen“<\/h2>\n
Schaltfläche „Ersetzen“<\/h2>\n
Schaltfläche „Alle ersetzen“<\/h2>\n
Wichtig: Lassen sich die grundlegenden Funktionen reproduzieren?<\/h2>\n
Per Screen-Klasse auf das aktuelle Datenblatt zugreifen<\/h2>\n
![\"Zugriff](\"..\/fileadmin\/_temp_\/2025_04\/pic_1560_001.png\")
<\/p>\n Screen.ActiveDatasheet.Recordset.RecordCount\r\n 100 <\/pre>\n
Zugriff auf das Datenblatt eines Formulars<\/h2>\n
![\"Fehler](\"..\/fileadmin\/_temp_\/2025_04\/pic_1560_002.png\")
<\/p>\n Screen.ActiveForm.Name\r\nfrmMitarbeiterUebersicht<\/pre>\n
Screen.ActiveControl.Parent.Name\r\nsfmMitarbeiterUebersicht<\/pre>\n
Mehr als nur Datenblatt<\/h2>\n
Weitere Erweiterungsmöglichkeiten<\/h2>\n
Ersetzen von Werten<\/h2>\n
„Suchen und Ersetzen“-Formular nachbauen<\/h2>\n
![\"Entwurf](\"..\/fileadmin\/_temp_\/2025_04\/pic_1560_006.png\")
<\/p>\n\n
Schaltflächen zum Entfernen von Such- und Ersetzungstexten<\/h2>\n
![\"Schaltflächen](\"..\/fileadmin\/_temp_\/2025_04\/pic_1560_015.png\")
<\/p>\nBei Eingabetaste automatisch suchen<\/h2>\n
Private Sub <\/span>cmdWeitersuchen_Click()\r\n MsgBox<\/span> \"Weitersuchen\"\r\nEnd Sub<\/span><\/pre>\nPrivate Sub <\/span>regSuchen_KeyDown(KeyCode As Integer<\/span>, _\r\n Shift As Integer<\/span>)\r\n Select Case KeyCode\r\n Case <\/span>13\r\n KeyCode = 0\r\n Call<\/span> cmdWeitersuchen_Click\r\n End Select<\/span>\r\nEnd Sub<\/span><\/pre>\nBei Escape-Taste automatisch schließen<\/h2>\n
Private Sub <\/span>cmdAbbrechen_Click()\r\n DoCmd.Close acForm, Me.Name\r\nEnd Sub<\/span><\/pre>\nKombinationsfelder füllen<\/h2>\n
\"Aktuelles Feld\";\"Aktuelles Dokument\"<\/pre>\n
![\"Einstellen](\"..\/fileadmin\/_temp_\/2025_04\/pic_1560_007.png\")
<\/p>\n\"Teil des Feldinhalts\";\"Ganzes Feld\";\"Anfang des Feldinhalts\"<\/pre>\n
\"Alle\";\"Aufwärts\";\"Abwärts\"<\/pre>\n
Private Sub <\/span>Form_Load()\r\n Me.cboSuchenIn = Me.cboSuchenIn.ItemData(0)\r\n Me.cboVergleichen = Me.cboVergleichen.ItemData(0)\r\n Me.cboSuchen = Me.cboSuchen.ItemData(0)\r\n Me.cmdWeitersuchen.SetFocus \r\nEnd Sub<\/span><\/pre>\n![\"Kombinationsfeld](\"..\/fileadmin\/_temp_\/2025_04\/pic_1560_008.png\")
<\/p>\nRegisterseiten programmieren<\/h2>\n
Private Sub <\/span>regErsetzen_Click()\r\n Me.cboErsetzenDurch.Visible = True<\/span>\r\n Me.cmdErsetzen.Visible = True<\/span>\r\n Me.cmdAlleErsetzen.Visible = True<\/span>\r\n Me.regSuchen.FontBold = 0\r\n Me.regErsetzen.FontBold = 1\r\n Me!Ersetzen = True<\/span>\r\nEnd Sub<\/span><\/pre>\nPrivate Sub <\/span>regSuchen_Click()\r\n Me.cboErsetzenDurch.Visible = False<\/span>\r\n Me.cmdErsetzen.Visible = False<\/span>\r\n Me.cmdAlleErsetzen.Visible = False<\/span>\r\n Me.regSuchen.FontBold = 1\r\n Me.regErsetzen.FontBold = 0\r\n Me!Ersetzen = False<\/span>\r\nEnd Sub<\/span><\/pre>\nFormular in verschiedenen Modi öffnen<\/h2>\n
DoCmd.OpenForm \"frmSuchenUndErsetzen\", OpenArgs:=\"Ersetzen\"<\/pre>\n
Private Sub <\/span>Form_Open(Cancel As Integer<\/span>)\r\n If <\/span>Not<\/span> IsNull(Me.OpenArgs) Then<\/span>\r\n If <\/span>Me.OpenArgs = \"Ersetzen\" Then<\/span>\r\n Call<\/span> regErsetzen_Click\r\n End If<\/span>\r\n End If<\/span>\r\nEnd Sub<\/span><\/pre>\n![\"Formular](\"..\/fileadmin\/_temp_\/2025_04\/pic_1560_009.png\")
<\/p>\nVerwalten der Suchen- und Ersetzen-Werte<\/h2>\n
Tabellen zum Speichern der Suchen- und Ersetzen-Zeichenketten<\/h2>\n
![\"Tabelle](\"..\/fileadmin\/_temp_\/2025_04\/pic_1560_011.png\")
<\/p>\n![\"Tabelle](\"..\/fileadmin\/_temp_\/2025_04\/pic_1560_012.png\")
<\/p>\n![\"Tabelle](\"..\/fileadmin\/_temp_\/2025_04\/pic_1560_010.png\")
<\/p>\nBeziehungen zwischen den Tabellen<\/h2>\n
![\"Beziehungen](\"..\/fileadmin\/_temp_\/2025_04\/pic_1560_014.png\")
<\/p>\nSpeichern und Laden der Konfigurationen<\/h2>\n
\n
Formular und Steuerelemente an die Tabellen binden<\/h2>\n
![\"Zuweisen](\"..\/fileadmin\/_temp_\/2025_04\/pic_1560_013.png\")
<\/p>\nAuf vorhandene Konfiguration prüfen<\/h2>\n
Ermitteln der aktuellen Datenblattansicht<\/h2>\n
Public Function <\/span>AktuelleDatenblattansicht() As String<\/span>\r\n Dim <\/span>strObjektname As String<\/span>\r\n Dim <\/span>objAktuellesObjekt As Object<\/span>\r\n On Error Resume Next<\/span>\r\n strObjektname = Screen.ActiveDatasheet.Name\r\n On Error GoTo<\/span> 0\r\n If <\/span>Len<\/span>(strObjektname) = 0 Then<\/span>\r\n On Error Resume Next<\/span>\r\n Set<\/span> objAktuellesObjekt = Screen.ActiveControl.Parent\r\n If <\/span>objAktuellesObjekt.CurrentView = acCurViewDatasheet Then<\/span>\r\n strObjektname = Screen.ActiveControl.Parent.Name\r\n End If<\/span>\r\n On Error GoTo<\/span> 0\r\n End If<\/span>\r\n If <\/span>Not<\/span> Len<\/span>(strObjektname) = 0 Then<\/span>\r\n AktuelleDatenblattansicht = strObjektname\r\n Exit Function<\/span>\r\n End If<\/span>\r\nEnd Function<\/span><\/pre>\n„Suchen und Ersetzen“-Dialog öffnen<\/h2>\n
Ereignis beim Öffnen des Formulars<\/h2>\n
Private Sub <\/span>Form_Open(Cancel As Integer<\/span>)\r\n Dim <\/span>strObjektname As String<\/span>\r\n strObjektname = AktuelleDatenblattansicht\r\n If <\/span>Len<\/span>(strObjektname) = 0 Then<\/span>\r\n MsgBox<\/span> \"Suchen und Ersetzen steht nur für die Datenblattansicht zur Verfügung.\", vbOKOnly + vbExclamation, _\r\n \"Keine Datenblattansicht aktiviert\"\r\n Cancel = True<\/span>\r\n Exit Sub<\/span>\r\n End If<\/span>\r\n If <\/span>Not<\/span> IsNull(Me.OpenArgs) Then<\/span>\r\n If <\/span>Me.OpenArgs = \"Ersetzen\" Then<\/span>\r\n bolErsetzen = True<\/span>\r\n End If<\/span>\r\n End If<\/span>\r\nEnd Sub<\/span><\/pre>\nPrivate <\/span>bolErsetzen As Boolean<\/span><\/pre>\nEreignis beim Laden des Formulars<\/h2>\n
Private Sub <\/span>Form_Load()\r\n