![\"Entwurf](\"..\/fileadmin\/_temp_\/2022_06\/pic_1397_001.png\")
<\/p>\nWenn der Kunde anruft, möchten Sie schnell den entsprechenden Kundendatensatz auf dem Bildschirm haben. Dazu stellen wir im vorliegenden Beitrag ein Formular samt Unterformular zusammen, mit denen die gewünschten Daten schnell ermittelt werden können. Im Hauptformular bieten wir einige Suchfunktionen an, im Unterformular liefern wir die den Suchkriterien entsprechenden Daten in der Datenblattansicht. Außerdem soll das Formular die Möglichkeit bieten, den gefundenen Kundendatensatz im Detailformular zu öffnen, damit wir auch noch die Bestellungen des Kunden einsehen können.<\/b><\/p>\nUnterformular für die Kundenliste<\/h2>\n
Bevor wir beginnen, das Hauptformular zu programmieren, legen wir zunächst das Unterformular an. Dann können wir dieses gleich im Anschluss direkt zum Hauptformular hinzufügen.<\/p>\n
Das neue Unterformular soll sfmKundenuebersicht <\/b>heißen und standardmäßig die Daten der Tabelle tblKunden <\/b>anzeigen. Deshalb stellen wir seine Eigenschaft Datensatzquelle <\/b>auf diese Tabelle ein. Anschließend können wir alle Felder der Feldliste in den Detailbereich des Formulars ziehen. Gegebenenfalls lassen wir das Primärschlüsselfeld ID <\/b>weg, da dieses nur zum Herstellen von Beziehungen dient und keine geschäftliche Funktion hat.<\/p>\n
Damit das Formular die Daten in der Datenblattansicht anzeigt, legen wir für die Eigenschaft Standardansicht <\/b>noch den Wert Datenblatt <\/b>fest (siehe Bild 1). Damit können wir die Arbeiten am Unterformular bereits beenden und dieses schließen.<\/p>\n
<\/p>\n
Bild 1: Entwurf des Unterformulars sfmKundenuebersicht<\/span><\/b><\/p>\n Anschließend erstellen wir das Hauptformular und speichern dieses direkt unter dem Namen frmKundenuebersicht<\/b>. Diesem weisen wir keine Datensatzquelle zu, weil es selbst keine Daten anzeigen soll – diese liefert allein das Unterformular. Im Hauptformular wollen wir nur Steuerelemente zum Durchsuchen der Kundendaten und zum Öffnen von Detaildatensätzen bereitstellen. Daher benötigen wir im Hauptformular auch nicht die Steuerelemente zum Navigieren in Datensätzen und stellen daher einige Eigenschaften ein. Die Eigenschaften Navigationsschaltflächen<\/b>, Datensatzmarkierer<\/b>, Bildlaufleisten <\/b>und Trennlinien <\/b>setzen wir auf den Wert Nein<\/b>, die Eigenschaft Automatisch zentrieren <\/b>auf Ja<\/b>.<\/p>\n Dann ziehen wir aus dem Navigationsbereich das Unterformular sfmKundenuebersicht <\/b>in den Detailbereich des Formularentwurfs von frmKundenuebersicht<\/b>. Das Bezeichnungsfeld des Unterformular-Steuerelements entfernen wir, da wir ja wissen, dass dieses Kundendaten anzeigt.<\/p>\n Damit das Unterformular beim Vergrößern des Hauptformulars ebenfalls vergrößert wird, stellen wir seine Eigenschaften Horizontaler Anker <\/b>und Vertikaler Anker <\/b>jeweils auf Beide <\/b>ein.<\/p>\n Wenn wir oben und unten ein wenig Platz für die Steuerelemente zum Suchen und zum Aufrufen der Anzeige der Kundendetails lassen, sieht der Entwurf nun wie in Bild 2 aus.<\/p>\n Bild 2: Haupt- und Unterformular im Entwurf<\/span><\/b><\/p>\n Damit kommen wir zu den Steuerelementen, mit denen wir die Filterkriterien für die anzuzeigenden Kunden eingeben wollen. Diese platzieren wir wie in Bild 3 im Bereich über dem Unterformular. Die Steuerelemente heißen:<\/p>\n Bild 3: Hinzufügen der Steuerelemente zum Filtern der Kundendatensätze<\/span><\/b><\/p>\n Das Filtern wollen wir einfach und schnell realisieren: Jede Eingabe in eines der Filterfelder soll unmittelbar die gefilterten Daten anzeigen. Außerdem soll immer im kompletten zu filternden Feld nach dem im jeweiligen Filterfeld eingegebenen Text gesucht werden. Sprich: Wenn der Benutzer im Feld txtFilterKundennummer <\/b>den Wert 1 <\/b>eingibt, sollen alle Datensätze angezeigt werden, die an beliebiger Stelle im Feld Kundennummer <\/b>den Wert 1 <\/b>enthalten.<\/p>\n Das heißt auch, dass wir für jedes der Steuerelemente zur Eingabe der Filterkriterien das Ereignis Bei Änderung <\/b>implementieren müssen. Mit diesem rufen wir dann jeweils eine weitere Prozedur auf, welche die jeweiligen Werte der Filter-Textfelder ausliest und ein entsprechendes SQL-Kriterium zusammenstellt.<\/p>\n Das Problem dabei ist, dass wir für die Inhalte der Filter-Textfelder auf unterschiedliche Eigenschaften zugreifen müssen. Normalerweise greifen wir einfach auf die Value<\/b>-Eigenschaft zu. Diese können wir allerdings nicht nutzen, wenn wir während der Eingabe auf den Inhalt im aktuellen Textfeld zugreifen wollen. Der Grund ist, dass die Value<\/b>-Eigenschaft erst mit dem aktuell im Textfeld enthaltenen Wert gefüllt wird, wenn der Benutzer die Eingabe bestätigt – beispielsweise, indem er das Textfeld verlässt und den Fokus auf das nächste Textfeld verschiebt. In diesem Fall lässt sich der aktuell im Textfeld dargestellte Text nur mit der Eigenschaft Text <\/b>auslesen.<\/p>\n Wir müssen also zumindest für das aktuelle Textfeld auf die Text<\/b>-Eigenschaft zugreifen und können nicht die Value<\/b>-Eigenschaft nutzen. Aber warum ist das überhaupt ein Problem? Können wir nicht einfach auf den Inhalt aller Felder über die Text<\/b>-Eigenschaft zugreifen? Das wiederum gelingt nicht, weil man nur für das Textfeld auf die Text<\/b>-Eigenschaft zugreifen kann, das aktuell den Fokus hat.<\/p>\n Wir müssen also den Inhalt des aktuell bearbeiteten Textfeldes mit der Text<\/b>– und den der übrigen Textfelder mit der Value<\/b>-Eigenschaft abfragen und prüfen, ob diese Kriteriumsausdrücke enthalten. Wobei die Value<\/b>-Eigenschaft wiederum die Standardeigenschaft der TextBox<\/b>-Klasse ist, weshalb wir diese gar nicht angeben müssen. Statt Me!txtFilterKundennummer.Value <\/b>können wir einfach Me!txtFilterKundennummer <\/b>schreiben.<\/p>\n Wir legen also zunächst für jedes der Filter-Textfelder eine Ereignisprozedur für das Ereignis Bei Änderung <\/b>an. Diese enthält für alle Filter-Textfelder den Aufruf einer weiteren Prozedur namens KundenFiltern <\/b>– wie hier am Beispiel der Prozedur txtFilterEMail <\/b>zu sehen:<\/p>\n Die Prozedur zum Zusammenstellen eines Filterausdrucks für das Unterformular können wir geradlinig und einfach aufbauen oder auch auf den ersten Blick etwas komplizierter, dafür aber flexibler. Wir schauen uns beide Varianten an. Die erste finden Sie in Listing 1.<\/p>\n Listing 1: Prozedur zum Einstellen des Filters für das Unterformular, einfache Version<\/span><\/b><\/p>\n Diese Version verwendet eine Variable namens strFilter<\/b>, um den Filterausdruck darin zusammenzustellen. Sie prüft für jedes der Filter-Textfelder, ob es sich dabei um das aktuelle Steuerelement handelt, also das Steuerelement, das aktuell den Fokus enthält. Das dient der Unterscheidung, ob wir die Text<\/b>– oder die Value<\/b>-Eigenschaft zum Ermitteln des jeweils in dem Steuerelement enthaltenen Textes verwenden müssen.<\/p>\n Um herauszufinden, ob wir es bei dem aktuellen Steuerelement mit dem aktiven Steuerelement zu tun haben, vergleichen wir dieses mit dem Verweis auf das Steuerelement, das wir mit der Eigenschaft ActiveControl <\/b>des Formulars ermitteln können. Sind beide gleich, handelt es sich um das aktive Steuerelement, sonst nicht. Ist das Steuerelement das aktive Steuerelement und ist dieses nicht leer, lesen wir den Inhalt mit der Text<\/b>-Eigenschaft und stellen damit einen Ausdruck wie den folgenden zusammen:<\/p>\n Vergleichsausdruck <\/b>entspricht dabei dem Inhalt des jeweiligen Textfeldes. Falls es sich bei dem aktuell untersuchten Steuerelement nicht um das aktive Steuerelement handelt, verwenden wir für den gleichen Ausdruck den Inhalt der Value<\/b>-Eigenschaft des Textfeldes.<\/p>\n <\/p>\n Das Problem ist, dass wir in dieser Version für jedes Textfeld die folgenden Zeilen, hier beispielhaft am Textfeld txtFilterKundennummer <\/b>gezeigt, in der Prozedur anlegen müssen:<\/p>\n In der Beispielprozedur haben wir aus Platzgründen nur zwei dieser Konstrukte abgebildet. strFilter <\/b>wird nur gefüllt, wenn überhaupt irgendeins der Filter-Textfelder einen Wert enthält. Dies prüft die folgende If…Then<\/b>-Bedingung. Entdeckt diese in strFilter <\/b>eine Zeichenfolge mit einer Länge größer als 0<\/b>, dann trennt sie das führende AND <\/b>ab und stellt den Filter für die Eigenschaft Filter <\/b>des Formulars im Unterformular-Steuerelement ein.<\/p>\n Außerdem aktiviert sie diesen, indem sie die Eigenschaft FilterOn <\/b>auf den Wert True <\/b>setzt. Enthält strFilter <\/b>eine leere Zeichenkette, stellt die Prozedur auch die Filter<\/b>-Eigenschaft auf eine leere Zeichenkette ein. Die Eigenschaft FilterOn <\/b>muss dann nicht auf False <\/b>gesetzt werden.<\/p>\n Es gibt eine Alternative zur vorherigen Variante der Einstellung des Filters im Unterformular. In dieser ersetzen wir die Untersuchung des Inhalts der Textfelder in jeweils einem eigenen verschachtelten If…Then<\/b>-Konstrukt durch eine Schleife, mit der wir die Filter-Textfelder durchlaufen.<\/p>\n Das ist möglich, weil wir die Benennung dieser Textfelder geschickt durchgeführt haben. All diese Textfelder beginnen nämlich mit der Zeichenkette txtFilter <\/b>und enden mit dem Namen des Feldes, für welches das Textfeld den Vergleichswert liefern soll. Auf diese Weise können wir die Anweisungen, die wir oben in acht einzelnen verschachtelten If…Then<\/b>-Konstrukten erledigt haben, innerhalb einer Schleife über alle Steuerelemente abhandeln.<\/p>\n Dazu deklarieren wir in der Prozedur aus Listing 2 zwei Objektvariablen. Die erste namens ctl <\/b>dient zum Durchlaufen aller Steuerelemente des Hauptformulars in einer For Each<\/b>-Schleife. Die zweite heißt txt <\/b>und hat den Datentyp TextBox<\/b>. Mit ihr referenzieren wir alle Textfelder unter den durchlaufenen Steuerelementen.<\/p>\n Listing 2: Prozedur zum Einstellen des Filters für das Unterformular per Schleife<\/span><\/b><\/p>\n Die For Each<\/b>-Schleife verwendet die Auflistung Me.Controls<\/b>, um alle Steuerelemente zu durchlaufen, und die Variable ctl <\/b>zum Referenzieren des jeweiligen Steuerelements. Die erste If…Then<\/b>-Bedingung innerhalb der Schleife prüft, ob die ersten neun Zeichen des Steuerelementnamens txtFilter <\/b>lauten.<\/p>\n Ist das der Fall, referenzieren wir das Steuerelement mit der Variablen txt<\/b>. Das machen wir eigentlich nur, um IntelliSense zu nutzen. Wir könnten auch einfach mit der Variablen ctl <\/b>weiterarbeiten.<\/p>\n Die zweite If…Then<\/b>-Bedingung prüft, ob es sich bei dem mit txt <\/b>referenzierten Steuerelement um das Steuerelement handelt, das aktuell den Fokus hat. Das dient wie im obigen Beispiel dazu, den Inhalt des Textfeldes entweder über die Text<\/b>– oder die Value<\/b>-Eigenschaft auszulesen.<\/p>\n Wenn dann noch die Eigenschaft Text <\/b>beziehungsweise Value <\/b>des Textfeldes nicht leer ist, fügt die Prozedur ein Kriterium zur Variablen strFilter <\/b>hinzu. Hier ermitteln wir mit Mid(txt.Name, 10) <\/b>aus einem Textfeld wie txtFilterKundennummer <\/b>den Wert Kundennummer<\/b>, welcher dem Namen des im Filterausdruck zu verwendenden Feldes entspricht.<\/p>\n Auf diese Weise durchlaufen wir alle Steuerelemente und setzen die Informationen aus den Feldern, deren Name mit txtFilter <\/b>beginnt, als Filterausdruck in der Variablen strFilter <\/b>zusammen. Die Zuweisung des Filterausdrucks zum Unterformular erfolgt analog zu der im zuvor beschriebenen Beispiel.<\/p>\n Die Programmierung der hier vorgestellten Schleife ist zwar etwas aufwendiger, als wenn wir die betroffenen Filter-Textfelder nacheinander untersuchen. Allerdings sparen wir eine Menge Code und, was noch wichtiger ist: Wir können nun weitere Filter-Textfelder hinzufügen oder vorhandene Entfernen und brauchen den Code nicht mehr zu ändern.<\/p>\n Die neuen Textfelder werden automatisch einbezogen. Die einzige Voraussetzung für ein Funktionieren des Filters ist, dass der Name der Filter-Textfelder mit txtFilter <\/b>beginnt und anschließend den Namen des zu filternden Feldes enthält.<\/p>\n Der Filter funktioniert nun wie gewünscht – wenn wir beispielsweise den Filter 9900000 <\/b>für die Kundennummer eingeben, erscheinen nur noch die Kundendatensätze, deren Kundennummer mit diesem Wert beginnt (siehe Bild 4).<\/p>\n Bild 4: Filtern der Kundendatensätze nach der Kundennummer<\/span><\/b><\/p>\n Neben dem Filtern der angezeigten Kunden im Unterformular wollen wir noch einige Funktionen zum Formular hinzufügen. Die meisten davon sollen per Schaltfläche ausgelöst werden, eine jedoch wollen wir auch per Doppelklick auf den gewünschten Eintrag erledigen:<\/p>\n Die Schaltflächen legen wir unterhalb des Unterformular-Steuerelements an.<\/p>\n Da wir für dieses die Eigenschaft Vertikaler Anker <\/b>auf Beide <\/b>eingestellt haben und dieses sich beim Vergrößern der Höhe des Formulars nach unten ausdehnt, müssen wir diese Eigenschaft für die Schaltflächen auf Unten <\/b>einstellen.<\/p>\n Sonst werden diese beim Vergrößern des Unterformulars von diesem verdeckt.<\/p>\n Immer wenn wir aus einer Übersicht heraus ein Detailformular öffnen, um einen bestehenden Datensatz zu bearbeiten oder einen neuen Datensatz anzulegen, können Änderungen am Datenbestand entstehen, die nach dem Schließen des jeweiligen Detailformulars direkt im aufrufenden Übersichtsformular abgebildet werden sollen.<\/p>\n Hier stellt sich die Frage, wie wir dies abbilden wollen. Wir haben zwei Möglichkeiten:<\/p>\n Da der Benutzer vielleicht andere Aktionen durchführen möchte, während das Formular frmKundeDetails <\/b>geöffnet ist, wollen wir in diesem Fall die zweite Methode nutzen. Dazu deklarieren wir im Klassenmodul des Formulars frmKundenuebersicht <\/b>die folgende Objektvariable:<\/p>\n In der Prozedur, die durch einen Klick auf die Schaltfläche cmdKundendetails <\/b>ausgelöst wird, lesen wir zuerst die ID des aktuell im Unterformular ausgewählten Kunden in die Variable lngKundeID <\/b>ein. Hat der Benutzer keinen Eintrag markiert, erhält lngKundeID <\/b>den Wert 0 <\/b>und die folgenden Schritte werden nicht ausgeführt.<\/p>\n Anderenfalls öffnet die Prozedur das Formular frmKundeDetails <\/b>mit der DoCmd.OpenForm<\/b>-Anweisung und übergibt mit dem WhereCondition<\/b>-Parameter den Filterausdruck für das zu öffnende Formular. Dieses sorgt dafür, dass das Formular den zu bearbeitenden Datensatz anzeigt:<\/p>\n Direkt im Anschluss referenziert die Prozedur das soeben geöffnete Formular mit der Variablen m_frmKundeDetails <\/b>und stellt seine Eigenschaft OnUnload <\/b>auf den Wert [Event Procedure] <\/b>ein.<\/p>\n Das ist gleichbedeutend mit dem Einstellen der Eigenschaft Beim Entladen <\/b>des Formulars auf den Wert [Ereignisprozedur] <\/b>und sorgt dafür, dass Access im eigenen Klassenmodul des Formulars (hier explizit) und in anderen Klassenmodulen, in denen eine Objektvariable mit einem Verweis auf das Formular erstellt wurde, nach einer entsprechenden Implementierung des Ereignisses gesucht wird:<\/p>\n Nun benötigen wir noch die Implementierung des Ereignisses im Klassenmodul des aufrufenden Formulars, also in Form_frmKundenuebersicht<\/b>.<\/p>\n Diese erstellen wir durch Auswahl des Eintrags m_frmKundeDetails <\/b>im linken Kombinationsfeld des Codefensters und der anschließenden Auswahl des Eintrags Unload <\/b>im rechten Kombinationsfeld. Danach fügen wir einen Aufruf der Prozedur KundenFiltern <\/b>hinzu:<\/p>\n Dies sorgt nun dafür, dass das Unterformular nach dem Aufruf des Formulars frmKundeDetails <\/b>und dem Schließen des Formulars neu gefiltert wird. So werden eventuelle Änderungen am Kundendatensatz direkt in das Unterformular übernommen.<\/p>\n Beim Anlegen eines neuen Kunden verfahren wir analog. Hier rufen wir das Formular frmKundeDetails <\/b>allerdings mit dem Wert acFormAdd <\/b>für den Parameter DataMode <\/b>auf.<\/p>\n Danach setzen wir wieder die Variable m_frmKundeDetails <\/b>auf das entsprechende Formular und legen die Ereigniseigenschaft auf [Event Procedure] <\/b>fest:<\/p>\n Nach dem Anlegen eines neuen Datensatzes und dem Schließen des Formulars frmKundeDetails <\/b>aktualisiert die Prozedur m_frmKundeDetails_Unload <\/b>den Inhalt des Unterformulars in frmKundenuebersicht<\/b>.<\/p>\n Zum Löschen ermitteln wir wieder die ID des markierten Kunden im Unterformular und speichern diesen in der Variablen lngKundeID<\/b> (siehe Listing 3). Hat lngKundeID <\/b>den Wert 0<\/b>, ist kein Datensatz markiert und die Prozedur wird beendet.<\/p>\n Listing 3: Prozedur zum Löschen eines Kunden per Mausklick<\/span><\/b><\/p>\n Anderenfalls erfolgt eine Rückfrage, ob der Kunde tatsächlich gelöscht werden soll. Klickt der Benutzer nun auf die Schaltfläche Ja<\/b>, erfolgt bei deaktivierter Fehlerbehandlung der Aufruf einer DELETE<\/b>-Anweisung für den angegebenen Datensatz der Tabelle tblKunden<\/b>.<\/p>\n In den Beziehungseigenschaften haben wir festgelegt, dass Kunden nicht gelöscht werden können, wenn für diese bereits ein verknüpfter Datensatz in der Tabelle tblBestellungen <\/b>hinterlegt wurde. Versucht der Benutzer, einen solchen Datensatz zu löschen, löst dies den Fehler mit der Nummer 3200 <\/b>aus, den wir nachfolgend in Form einer benutzerdefinierten Fehlermeldung behandeln.<\/p>\n Liefert das Err-Objekt anschließend den Wert 0 zurück, wird der Datensatz gelöscht und die Prozedur ruft die Routine KundenFiltern <\/b>auf, um die im Unterformular angezeigten Daten zu aktualisieren. <\/p>\n Alle anderen Werte von Err.Number <\/b>führen zur Anzeige des jeweiligen Fehlers in einem Meldungsfenster.<\/p>\n Wenn der Benutzer doppelt auf einen der Einträge im Unterformular klickt, soll der entsprechende Kundendatensatz ebenfalls im Formular frmKundeDetails <\/b>erscheinen. Hier stehen wir vor der Aufgabe, für alle im Unterformular enthaltenen gebundenen Steuerelemente eine Ereignisprozedur anzulegen, die durch das Ereignis Beim Doppelklicken <\/b>ausgelöst wird. Diese sollen wie die zuvor beschriebene Prozedur cmdKundendetails_Click <\/b>das Formular frmKundeDetails <\/b>aufrufen und den aktuell im Unterformular markierten Kundendatensatz anzeigen.<\/p>\n Es ist allerdings nicht sinnvoll, die Funktion dieser Prozedur einfach nochmal im Klassenmodul des Unterformulars zu reproduzieren. Das erhöht nur den Aufwand bei eventuellen Überarbeitungen des VBA-Codes. Also wollen wir dafür sorgen, dass ein Doppelklick auf ein gebundenes Feld im Unterformular direkt die Prozedur cmdKundendetails_Click <\/b>aufruft.<\/p>\n Dazu gibt es zwei Möglichkeiten:<\/p>\n Letztere Variante ist mit deutlich größerem Programmieraufwand verbunden, also wählen wir die erste Variante. Für die Prozedur cmdKundendetails_Click <\/b>ändern wir lediglich das Schlüsselwort Private <\/b>in Public<\/b>:<\/p>\n Im Unterformular platzieren wir dann die folgende Ereignisprozedur für das Steuerelement Kundennummer<\/b>:<\/p>\n Den Aufruf dieser Prozedur fügen wir analog für alle übrigen gebundenen Steuerelemente hinzu. Genau genommen übertragen wir den Aufruf der Prozedur cmdKundendetails_Click <\/b>in eine neue Prozedur, die wie folgt aussieht:<\/p>\nHauptformular erstellen<\/h2>\n
![\"Haupt-](\"..\/fileadmin\/_temp_\/2022_06\/pic_1397_002.png\")
<\/p>\nSteuerelemente zum Filtern der Kunden hinzufügen<\/h2>\n
![\"Hinzufügen](\"..\/fileadmin\/_temp_\/2022_06\/pic_1397_003.png\")
<\/p>\n\n
Unterschiedliche Eigenschaften zum Ermitteln der Vergleichskriterien<\/h2>\n
Prozedur zum Ermitteln des Filterkriteriums für das Unterformular<\/h2>\n
Private Sub <\/span>txtFilterEMail_Change()\r\n KundenFiltern\r\nEnd Sub<\/span><\/pre>\nEinfache Variante zum Zusammensetzen des Filterkriterums<\/h2>\n
Private Sub <\/span>KundenFiltern()\r\n Dim <\/span>strFilter As String<\/span>\r\n If <\/span>Me!txtFilterKundennummer Is Me.ActiveControl Then<\/span>\r\n If <\/span>Not<\/span> Len<\/span>(Me!txtFilterKundennummer.Text) = 0 Then<\/span>\r\n strFilter = strFilter & \" AND Kundennummer LIKE ''*\" & Me!txtFilterKundennummer.Text & \"*''\"\r\n End If<\/span>\r\n Else<\/span>\r\n If <\/span>Not<\/span> Len<\/span>(Me!txtFilterKundennummer.Value) = 0 Then<\/span>\r\n strFilter = strFilter & \" AND Kundennummer LIKE ''*\" & Me!txtFilterKundennummer.Value & \"*''\"\r\n End If<\/span>\r\n End If<\/span>\r\n If <\/span>Me!txtFilterFirma Is Me.ActiveControl Then<\/span>\r\n If <\/span>Not<\/span> Len<\/span>(Me!txtFilterFirma.Text) = 0 Then<\/span>\r\n strFilter = strFilter & \" AND Firma LIKE ''*\" & Me!txtFilterFirma.Text & \"*''\"\r\n End If<\/span>\r\n Else<\/span>\r\n If <\/span>Not<\/span> Len<\/span>(Me!txtFilterFirma.Value) = 0 Then<\/span>\r\n strFilter = strFilter & \" AND txtFilterFirma LIKE ''*\" & Me!txtFilterFirma.Value & \"*''\"\r\n End If<\/span>\r\n End If<\/span>\r\n ''...\r\n If <\/span>Not<\/span> Len<\/span>(strFilter) = 0 Then<\/span>\r\n strFilter = Mid<\/span>(strFilter, 5)\r\n With<\/span> Me!sfmKundenuebersicht.Form\r\n .Filter = strFilter\r\n .FilterOn = True<\/span>\r\n End With<\/span>\r\n Else<\/span>\r\n Me!sfmKundenuebersicht.Form.Filter = \"\"\r\n End If<\/span>\r\nEnd Sub<\/span><\/pre>\n AND Kundennummer LIKE ''*Vergleichsausdruck*''<\/pre>\n
If <\/span>Me!txtFilterKundennummer Is Me.ActiveControl Then<\/span>\r\n If <\/span>Not<\/span> Len<\/span>(Me!txtFilterKundennummer.Text) = 0 Then<\/span>\r\n strFilter = strFilter & \" AND Kundennummer LIKE ''*\" & Me!txtFilterKundennummer.Text & \"*''\"\r\n Else<\/span>\r\n strFilter = strFilter & \" AND Kundennummer LIKE ''*\" & Me!txtFilterKundennummer.Value & \"*''\"\r\n End If<\/span>\r\nEnd If<\/span><\/pre>\nAlternative Programmierung des Filters<\/h2>\n
Private Sub <\/span>KundenFiltern()\r\n Dim <\/span>ctl As <\/span>Control\r\n Dim <\/span>txt As <\/span>TextBox\r\n Dim <\/span>strFilter As String<\/span>\r\n For Each ctl In Me.Controls\r\n If <\/span>Left<\/span>(ctl.Name, 9) = \"txtFilter\" Then<\/span>\r\n Set<\/span> txt = ctl\r\n If <\/span>txt Is Me.ActiveControl Then<\/span>\r\n If <\/span>Not<\/span> Len<\/span>(txt.Text) = 0 Then<\/span>\r\n strFilter = strFilter & \" AND \" & Mid<\/span>(txt.Name, 10) & \" LIKE ''*\" & txt.Text & \"*''\"\r\n End If<\/span>\r\n Else<\/span>\r\n If <\/span>Not<\/span> Len<\/span>(Nz(txt.Value, \"\")) = 0 Then<\/span>\r\n strFilter = strFilter & \" AND \" & Mid<\/span>(txt.Name, 10) & \" LIKE ''*\" & txt.Value & \"*''\"\r\n End If<\/span>\r\n End If<\/span>\r\n End If<\/span>\r\n Next<\/span> ctl\r\n If <\/span>Not<\/span> Len<\/span>(strFilter) = 0 Then<\/span>\r\n strFilter = Mid<\/span>(strFilter, 5)\r\n With<\/span> Me!sfmKundenuebersicht.Form\r\n .Filter = strFilter\r\n .FilterOn = True<\/span>\r\n End With<\/span>\r\n Else<\/span>\r\n Me!sfmKundenuebersicht.Form.Filter = \"\"\r\n End If<\/span>\r\nEnd Sub<\/span><\/pre>\nVorteil beim Filtern per Schleife<\/h2>\n
![\"Filtern](\"..\/fileadmin\/_temp_\/2022_06\/pic_1397_004.png\")
<\/p>\nSchaltflächen für weitere Funktionen<\/h2>\n
\n
Umgang mit geänderten Daten aus dem Formular frmKundeDetails<\/h2>\n
\n
Dim <\/span>WithEvents m_frmKundeDetails As <\/span>Form<\/pre>\nPrivate Sub <\/span>cmdKundendetails_Click()\r\n Dim <\/span>lngKundeID As Long<\/span>\r\n lngKundeID = Nz(Me!sfmKundenuebersicht.Form.ID, 0)\r\n If <\/span>Not<\/span> lngKundeID = 0 Then<\/span>\r\n DoCmd.OpenForm \"frmKundeDetails\", WhereCondition:=\"ID = \" & lngKundeID<\/pre>\n Set<\/span> m_frmKundeDetails = Forms!frmKundeDetails\r\n With<\/span> m_frmKundeDetails\r\n .OnUnload = \"[Event Procedure]\"\r\n End With<\/span>\r\n End If<\/span>\r\nEnd Sub<\/span><\/pre>\nPrivate Sub <\/span>m_frmKundeDetails_Unload(Cancel As Integer<\/span>)\r\n KundenFiltern\r\nEnd Sub<\/span><\/pre>\nAnlegen eines neuen Kunden<\/h2>\n
Private Sub <\/span>cmdNeuerKunde_Click()\r\n DoCmd.OpenForm \"frmKundeDetails\", DataMode:=acFormAdd\r\n Set<\/span> m_frmKundeDetails = Forms!frmKundeDetails\r\n With<\/span> m_frmKundeDetails\r\n .OnUnload = \"[Event Procedure]\"\r\n End With<\/span>\r\nEnd Sub<\/span><\/pre>\nLöschen eines Kundendatensatzes<\/h2>\n
Private Sub <\/span>cmdKundeLoeschen_Click()\r\n Dim <\/span>lngKundeID As Long<\/span>\r\n Dim <\/span>db As <\/span>DAO.Database\r\n lngKundeID = Me!sfmKundenuebersicht.Form.ID\r\n If <\/span>Not<\/span> lngKundeID = 0 Then<\/span>\r\n If <\/span>MsgBox<\/span>(\"Soll der Kunde wirklich gelöscht werden?\", vbYesNo + vbExclamation, \"Kunde löschen\") = vbYes Then<\/span>\r\n On Error Resume Next<\/span>\r\n Set<\/span> db = CurrentDb\r\n db.Execute \"DELETE FROM tblKunden WHERE ID = \" & lngKundeID, dbFailOnError\r\n Select Case Err.Number\r\n Case <\/span>3200\r\n MsgBox<\/span> \"Der Kunde kann nicht gelöscht werden, da für diesen bereits Bestellungen angelegt wurden.\", _\r\n vbExclamation, \"Löschen abgebrochen\"\r\n Case <\/span>0\r\n KundenFiltern\r\n Case Else<\/span>\r\n MsgBox<\/span> Err.Number & \" \" & Err.Description\r\n End Select<\/span>\r\n End If<\/span>\r\n End If<\/span>\r\nEnd Sub<\/span><\/pre>\nÖffnen eines Kundendatensatzes per Doppelklick auf den Eintrag im Unterformular<\/h2>\n
\n
Public Sub <\/span>cmdKundendetails_Click()\r\n ...\r\nEnd Sub<\/span><\/pre>\nPrivate Sub <\/span>Kundennummer_DblClick(Cancel As Integer<\/span>)\r\n Me.Parent.cmdKundendetails_Click\r\nEnd Sub<\/span><\/pre>\n