<\/p>\n
![\"Die](\"..\/fileadmin\/_temp_\/2024_02\/pic_1488_001.png\")
<\/p>\n
Bild 1: Die gewünschten Formulare<\/span><\/b><\/p>\n Eine gute Basis für das Anzeigen und Bearbeiten von Daten ist die folgende Konstellation: Wir verwenden ein Haupt- und Unterformular, um die Daten einer Tabelle in einer Übersichtsansicht anzuzeigen. Dabei können wir die Daten, die im Unterformular angezeigt werden, filtern und sortieren. Außerdem stellen wir Schaltflächen bereit, mit denen wir die Datensätze anlegen, bearbeiten und löschen können. Zum Bearbeiten verwenden wir ein weiteres Formular, das die Daten in einer übersichtlichen Ansicht darstellt. Zusätzlich fügen wir noch ein den Code hinzu, der für das Interagieren der Formulare untereinander notwendig ist. Diese Konstellation von Formularen können wir für alle möglichen Tabellen verwenden und schaffen so die Basis einer professionellen Anwendung. Anpassungen können schließlich dort vorgenommen werden, wo m:n- oder 1:n-Beziehungen dargestellt werden sollen.<\/b><\/p>\n Eine oft verwendete Konstellation aus Formularen zur Darstellung der Daten einer Tabelle sehen wir in Bild 1. Links finden wir ein aus Haupt- und Unterformular bestehendes Formular, das im Unterformular die Daten in der Datenblattansicht anzeigt und im Hauptformular Steuerelemente, um mit den Daten zu arbeiten. Hier können wir nach den Daten im Unterformular suchen, einen neuen Datensatz hinzufügen, einen Datensatz zur Bearbeitung öffnen oder den markierten Datensatz löschen. Ein Doppelklick auf einen der Einträge im Unterformular soll ebenfalls das Bearbeitungsformular öffnen.<\/p>\n Bild 1: Die gewünschten Formulare<\/span><\/b><\/p>\n Dieses sieht wie das Formular rechts in der Abbildung aus. Es liefert einfach die Felder der zugrunde liegenden Tabelle und bietet zwei Schaltflächen, mit denen Änderungen übernommen oder verworfen werden können.<\/p>\n Die Erstellung dieser Formulare beginnen wir immer mit dem Unterformular des Übersichtsformulars. Warum das? Weil wir dieses, wenn wir es fertiggestellt haben, direkt in das im Anschluss erstellte Hauptformular einbauen können.<\/p>\n Das Unterformular erstellen wir als neues, leeres Formular. Diesem weisen wir für die Eigenschaft Datensatzquelle <\/b>die Tabelle mit den anzuzeigenden Daten zu, in diesem Fall tblMitglieder<\/b>.<\/p>\n Dann ziehen wir aus dem Bereich Feldliste <\/b>alle Felder in den Detailbereich, die das Unterformular anzeigen soll (siehe Bild 2).<\/p>\n Bild 2: Erstellen des Unterformulars der Übersicht<\/span><\/b><\/p>\n Damit das Unterformular seine Daten in der Datenblattansicht präsentiert, stellen wir die Eigenschaft Standardansicht <\/b>auf den Wert Datenblatt <\/b>ein.<\/p>\n Außerdem wollen wir, dass der Benutzer mit einem Doppelklick auf einen der Einträge im Unterformular das Formular mit der Detailansicht öffnen kann. Dazu hinterlegen wir für die Ereigniseigenschaft Beim Doppelklicken <\/b>eines jeden Steuerelements den Wert [Ereignisprozedur] <\/b>und legen durch einen Klick auf die Schaltfläche mit den drei Punkten die entsprechende Ereignisprozedur an (siehe Bild 3). Die hier hinzugefügte Ereignisprozedur füllen wir wie folgt mit einer einzigen Anweisung:<\/p>\n Bild 3: Ereignis Beim Doppelklicken implementieren<\/span><\/b><\/p>\n Auf die gleiche Weise hinterlegen wir eine solche Ereignisprozedur für die übrigen Steuerelemente. Die hier aufgerufene Prozedur EditDetails <\/b>finden wir in Listing 1. Sie öffnet das Detailformular namens frmMitgliederDetails <\/b>mit der DoCmd.OpenForm<\/b>-Methode. Dabei stellt sie den Öffnungsmodus auf einen modalen Dialog ein. Als Datenmodus verwenden wir den Bearbeitungsmodus. Außerdem übergibt die Prozedur eine Bedingung an das Formular, die dafür sorgt, dass es genau den Datensatz anzeigt, der soeben doppelt angeklickt wurde.<\/p>\n Listing 1: Öffnen der Detailansicht eines Datensatzes<\/span><\/b><\/p>\n Wenn der Benutzer das Formular geschlossen hat, läuft die aufrufende Prozedur weiter und prüft, ob das Formular geschlossen ist. Falls nicht, und das ist der Fall, wenn der Benutzer im Detailformular die OK<\/b>-Schaltfläche gedrückt hat, aktualisiert die Prozedur seine eigene Datenquelle und schließt das Detailformular mit DoCmd.Close <\/b>endgültig.<\/p>\n Hat der Benutzer hingegen die Abbrechen<\/b>-Schaltfläche gedrückt, was bedeutet, das Änderungen verworfen und das Formular geschlossen werden soll, wird das Formular direkt richtig geschlossen. In diesem Fall müssen im aufrufenden Formular keine Daten aktualisiert werden.<\/p>\n Danach können wir das Unterformular schließen und es unter dem Namen sfmMitgliederUebersicht <\/b>speichern.<\/p>\n Das Hauptformular öffnen wir ebenfalls als neues, leeres Formular. Dieses benötigte keine Datensatzquelle, da die Daten ja bereits im Unterformular angezeigt werden. Stattdessen fügen wir vier Schaltflächen namens cmdAdd<\/b>, cmdEdit<\/b>, cmdDelete <\/b>und cmdOK <\/b>hinzu. Außerdem legen wir ein Textfeld namens txtSearch <\/b>an.<\/p>\n Dann ziehen wir das Unterformular sfmMitgliederUebersicht<\/b> aus dem Navigationsbereich in das Hauptformular und positionieren alle Elemente ungefähr wie in Bild 4.<\/p>\n Bild 4: Das Unterformular im Hauptformular<\/span><\/b><\/p>\n In der aktuellen Ansicht ist das Formular recht klein gehalten. Der Benutzer soll es aber vergrößern können und dabei sollen sich auch bestimmte Elemente vergrößern beziehungsweise verschoben werden. In diesem Fall ist das Unterformular sfmMitgliederUebersicht <\/b>das Element, das sowohl vertikal als auch horizontal angepasst werden soll, wenn der Benutzer das Hauptformular vergrößert oder verkleinert. Deshalb stellen wir die Eigenschaften Horizontaler Anker <\/b>und Vertikaler Anker <\/b>auf den Wert Beide <\/b>ein. Das wirkt sich automatisch auch auf das Bezeichnungsfeld des Unterformular-Steuerelements aus, für das die Eigenschaften nun auf Rechts <\/b>und Unten <\/b>eingestellt sind. Diese legen wir wieder auf Links <\/b>und Oben <\/b>fest. <\/p>\n Da sich das Unterformular-Steuerelement beim Vergrößern der Höhe nach unten ausdehnt, müssen wir die darunter liegenden Steuerelemente ebenfalls nach unten verschieben. Deshalb stellen wir für die Schaltfläche cmdOK <\/b>den Wert der Eigenschaft Vertikaler Anker <\/b>auf Unten <\/b>ein.<\/p>\n Die Schaltflächen haben wir ein wenig angepasst, da das Standarddesign etwas altbacken daherkommt. Dazu haben wir zunächst Bilder hinzugefügt. Das gelingt am schnellsten, indem man im Entwurf die jeweilige Schaltfläche anklickt und den Befehl Bild einfügen <\/b>aus dem Ribbon-Tab Formularentwurf<\/b> auswählt. Danach können wir das gewünschte Icon, am besten im PNG-Format, selektieren und es wird direkt der Schaltfläche zugeordnet. Einmal zur Anwendung hinzugefügte Schaltflächen sind danach über die Bildergalerie verfügbar (siehe Bild 5).<\/p>\n Bild 5: Hinzufügen von Icons zu Schaltflächen<\/span><\/b><\/p>\n Damit der Text rechts vom Icon erscheint, stellen wie die Eigenschaft Anordnung der Bildbeschriftung <\/b>auf Rechts <\/b>ein.<\/p>\n Den Rahmen haben wir durch Einstellen der Eigenschaft Rahmenart <\/b>auf den Wert Transparent <\/b>ausgeblendet. Für die Schrift haben wir eine andere Farbe gewählt, außerdem wird diese nun fett dargestellt. Außerdem haben wir auch den Hintergrund durch Einstellen der Eigenschaft Hintergrundart <\/b>auf Transparent <\/b>ausgeblendet.<\/p>\n Nun fügen wir die Ereignisprozeduren für die Schaltflächen im Hauptformular hinzu. Wie beginnen mit der einfachsten Schaltfläche cmdOK<\/b>. Diese löst die folgende Prozedur aus, die einfach das Formular schließt:<\/p>\n Damit kommen wir zur Suchfunktion. Das Suchfeld txtSearch<\/b> soll auf die Eingabe eines jeden Zeichens reagieren und die angezeigten Datensätze im Unterformular filtern. Dazu reicht es nicht aus, mit dem Ereignis Nach Aktualisierung <\/b>auf das Betätigen der Eingabetaste oder das Verlassen des Steuerelements zu reagieren. Wir verwenden hier das Ereignis Bei Änderung<\/b>, das bei der Eingabe jedes einzelnen Zeichens und auch beim Löschen von Zeichen ausgelöst wird.<\/p>\n Dafür hinterlegen wir die Prozedur aus Listing 2. Hier lesen wir zuerst den aktuellen Text aus dem Textfeld txtSearch <\/b>ein. Es reicht nicht, einfach mit Me!txtSearch <\/b>oder Me!txtSearch.Value <\/b>den Wert des Textfeldes auszulesen, denn dieser ändert sich erst mit dem Speichern des Inhalts beispielsweise durch Verlassen.<\/p>\n Listing 2: Code für die Suchfunktion<\/span><\/b><\/p>\n Stattdessen verwenden wir die Eigenschaft Text<\/b>, die den tatsächlich angezeigten Text liefert. Den damit ermittelten Wert tragen wir in die Variable strSearch <\/b>ein.<\/p>\n Erst wenn die Länge dieser Zeichenkette größer als 0 <\/b>ist, stellen wir einen Filterausdruck zusammen. Bei einer leeren Zeichenketten setzen wir den Filter für das Unterformular einfach mit FilterOn = False <\/b>zurück, sodass dieses alle Datensätze der Datenquelle anzeigt.<\/p>\n Finden wir jedoch einen Text in strSearch<\/b>, beginnen wir mit dem Zusammenstellen des Filterausdrucks, den wir in der Variablen strFilter <\/b>verwalten. In diesem Beispiel wollen wir die Felder Vorname<\/b>, Nachname<\/b>, Strasse<\/b>, PLZ<\/b>, Ort<\/b>, EMail <\/b>und Telefon <\/b>nach dem Suchbegriff durchsuchen und alle Datensätze zurückliefern, in denen der Suchbegriff in irgendeinem der Felder auftritt.<\/p>\n Deshalb verbinden wir den Suchausdruck für das jeweilige Feld, also beispielsweise Vorname LIKE “*Suchbegriff*“<\/b>, mit dem OR<\/b>-Operator. Die Sternchen verwenden wir, damit der Suchbegriff an beliebiger Stelle vorkommen kann.<\/p>\n Am Ende erhalten wir ein Kriterium, das alle Felder nach dem angegebenen Suchbegriff durchsucht.<\/p>\n Diesen weisen wir schließlich der Eigenschaft Filter <\/b>des mit der Form<\/b>-Eigenschaft des Unterformular-Steuerelements referenzierten Formulars zu. Mit FilterOn = True <\/b>stellen wir dann den Filter scharf.<\/p>\n Dies führt dazu, dass die Ergebnismenge tatsächlich nach der Eingabe eines jeden Zeichens angepasst wird (siehe Bild 6).<\/p>\n Bild 6: Die Suchfunktion in Aktion<\/span><\/b><\/p>\n Zum Hinzufügen eines neuen Datensatzes soll der Benutzer die Schaltfläche cmdAdd <\/b>mit der Beschriftung Neu <\/b>betätigen.<\/p>\n Die löst die Prozedur aus Listing 3 aus. Diese trägt den Namen des Detailformulars in die Variable strForm <\/b>ein. Warum verwenden wir hier eine Variable? Weil der Name des Formulars gleich an mehreren Stellen verwendet wird. Sollten wir diesen Namen einmal ändern oder gar den hier verwendeten Code noch in einem anderen Formular verwenden, brauchen wir den Formularnamen nur an einer Stelle zu ändern.<\/p>\n Listing 3: Code zum Anlegen eines neuen Datensatzes<\/span><\/b><\/p>\n In diesem Fall nutzen wir die Variable, um das Formular frmMitgliederDetails <\/b>mit der DoCmd.OpenForm<\/b>-Methode zu öffnen. Dieses öffnen wir als modalen Dialog (WindowMode:=acDialog<\/b>), damit der aufrufende Code angehalten wird und erst nach dem Schließen oder Ausblenden des geöffneten Formulars weiterläuft. Außerdem stellen wir den Datenmodus zum Anlegen eines neuen Datensatzes ein (DataMode:=acFormAdd<\/b>).<\/p>\n Dadurch erscheint das Formular frmMitgliederDetails <\/b>wie in Bild 7 mit einem neuen, leeren Datensatz. Nachdem wir dort einen neuen Datensatz eingetragen haben und die OK<\/b>-Schaltfläche betätigen, wird das Formular mit Me.Visible = False <\/b>ausgeblendet und der aufrufende Code wird fortgesetzt.<\/p>\n Bild 7: Das automatisch generierte Formular<\/span><\/b><\/p>\n Dieser stellt mit der Hilfsfunktion IstFormularGeoeffnet <\/b>fest, dass das Formular noch geöffnet ist. Daraufhin liest sie den Primärschlüsselwert des neu angelegten Datensatzes in die Variable lngID <\/b>ein und schließt das Detailformular. Dann aktualisiert sie die Daten im Unterformular sfmMitgliederUebersicht <\/b>mit der Requery<\/b>-Methode und stellt den Datensatzzeiger des Recordsets des Unterformulars auf den neuen Datensatz ein.<\/p>\n Wenn der Benutzer das aufgerufene Formular mit der Schaltfläche cmdCancel <\/b>schließt, wird dieses mit DoCmd.Close <\/b>direkt geschlossen. In diesem Fall sind keine Aktualisierungen im aufrufenden Formular nötig.<\/p>\n Die Schaltfläche cmdEdit <\/b>ruft ebenfalls das Formular frmMitgliederDetails <\/b>auf (siehe Listing 4). Auch hier verwenden wir wieder eine Variable mit dem Namen des zu öffnenden Formulars. Außerdem ermitteln wir den Primärschlüsselwert des aktuell im Unterformular sfmMitgliederUebersicht <\/b>markierten Datensatzes und speichern diesen in der Variablen lngID<\/b>. Ist dort aktuell kein Datensatz markiert, landet der Wert 0 <\/b>in der Variablen. Ob lngID <\/b>den Wert 0 <\/b>enthält, prüft die folgende If…Then<\/b>-Bedingung. Nur wenn diese nicht den Wert 0 <\/b>enthält, öffnet die Prozedur das Formular frmMitgliederDetails<\/b>. Wir verwenden wieder den Parameter WindowMode:=acDialog<\/b>, um das Formular als modalen Dialog zu öffnen.<\/p>\n Listing 4: Code zum Bearbeiten eines Datensatzes<\/span><\/b><\/p>\n Diesmal legen wir als Datenmodus acFormEdit <\/b>fest. Außerdem übergeben wir mit der WhereCondition <\/b>den zu bearbeitenden Datensatz, sodass dieser wie in Bild 8 im Detailformular angezeigt wird.<\/p>\n Bild 8: Bearbeiten eines Datensatzes<\/span><\/b><\/p>\n Nach dem Bearbeiten klickt der Benutzer wieder entweder auf cmdOK<\/b>, was dazu führt, dass das Formular frmMitgliederDetails <\/b>ausgeblendet wird und der aufrufende Code fortgesetzt wird. Dieser prüft, ob das Formular noch geöffnet ist, und schließt es in diesem Fall. Außerdem wird das Unterformular mit Refresh <\/b>aktualisiert.<\/p>\n Warum diesmal mit Refresh <\/b>und nicht mit Requery<\/b>? Weil Requery die komplette Datenquelle aktualisiert und vor allem wieder den ersten Datensatz markiert. Refresh<\/b> aktualisiert nur den aktuellen Datensatz und vor allem bleibt der Datensatzzeiger auf dem aktuellen Datensatz stehen.<\/p>\n Auch hier geschieht nichts, wenn der Benutzer das Formular frmMitgliederDetails <\/b>mit der Schaltfläche cmdCancel <\/b>schließt, wodurch eventuell getätigte Änderungen verworfen werden.<\/p>\n Wenn der Benutzer bei markiertem Datensatz im Unterformular die Schaltfläche cmdDelete<\/b>, löst er die Prozedur aus Listing 5 aus.<\/p>\n Listing 5: Code zum Löschen eines Datensatzes<\/span><\/b><\/p>\n Diese merkt sich gleich zu Beginn zwei Informationen:<\/p>\n Wenn lngID <\/b>nicht 0 <\/b>ist, erscheint eine Meldung mit einer Rückfrage, ob der Datensatz tatsächlich gelöscht werden soll (siehe Bild 9). In diesem Fall löscht die Prozedur den Datensatz mit der DELETE<\/b>-Anweisung, die als Parameter der Execute<\/b>-Methode der aktuellen Datenbank abgesetzt wird. Wurde nicht der erste Datensatz gelöscht, was einem Wert von 0 <\/b>für die Eigenschaft AbsolutePosition <\/b>entspricht, stellt die Prozedur den Datensatzzeiger nun auf die Position des Datensatzes ein, der sich vor dem gelöschten Datensatz befindet.<\/p>\n Bild 9: Löschen eines Datensatzes<\/span><\/b><\/p>\n Das Detailformular frmMitgliederDetails <\/b>soll jeweils einen neuen, leeren oder einen vorhandenen Datensatz der Tabelle tblMitglieder <\/b>anzeigen. Dazu stellen wir zuerst die Eigenschaft Datensatzquelle <\/b>auf den Namen dieser Tabelle ein (siehe Bild 10). In dieser Abbildung sehen wir auch bereits die Steuerelemente, die wir aus der Feldliste in den Formularentwurf gezogen haben. Außerdem haben wir hier die beiden Schaltflächen cmdOK <\/b>und cmdCancel <\/b>angelegt. Diese beiden Schaltflächen haben wir mit dem gleichen Design versehen wie die im anderen Formular.<\/p>\n Bild 10: Entwurf des Formulars frmMitgliederDetails<\/span><\/b><\/p>\n Die Prozeduren hinter diesen Schaltflächen sind recht einfach gehalten. Die Schaltfläche cmdOK <\/b>blendet das Formular einfach aus. Auf diese Weise kann der Code, der dieses Formular als modalen Dialog aufgerufen hat, fortgesetzt werden und noch Informationen aus dem Formular auslesen, bevor er dieses schließt:<\/p>\n Die Abbrechen<\/b>-Schaltfläche cmdCancel <\/b>setzt mit Me.Undo <\/b>zuerst alle nicht gespeicherten Änderungen zurück und schließt das Formular dann mit DoCmd.Close<\/b>:<\/p>\n Im Übersichtsformular frmMitgliederUebersicht <\/b>haben wir Elemente wie die Navigationsschaltflächen und den Datensatzmarkierer ausgeblendet. Dort war das sinnvoll, weil das Hauptformular ohnehin keine Datensätze anzeigt, durch die man navigieren könnte. Beim Formular frmMitgliederDetails <\/b>sieht das anders aus. Hier könnten wir diese Elemente grundsätzlich durchaus gebrauchen. Allerdings soll das Formular immer nur den zu bearbeitenden oder einen neuen Datensatz anzeigen. Eigentlich benötigen wir diese Elemente also doch nicht. Deshalb stellen wir auch hier die Eigenschaften Datensatzmarkierer<\/b>, Navigationsschaltflächen<\/b>, Bildlaufleisten <\/b>und Trennlinien <\/b>auf Nein <\/b>und Automatisch zentrieren <\/b>auf Ja <\/b>ein.<\/p>\n Damit der Benutzer die Funktion dieser beiden Schaltflächen auch per Tastatur auslösen kann, nehmen wir noch Einstellungen an den Eigenschaften der Schaltflächen vor. Für die Schaltfläche cmdOK <\/b>legen wir dazu für die Eigenschaft Standard <\/b>den Wert Ja <\/b>fest (siehe Bild 11). Dadurch wird die Ereignisprozedur dieser Schaltfläche ausgelöst, wenn der Benutzer die Eingabetaste betätigt.<\/p>\n Bild 11: Einstellen der Schaltflächen-Eigenschaften<\/span><\/b><\/p>\n Auf die gleiche Weise stellen wir die Eigenschaft Abbrechen <\/b>für die Schaltfläche cmdCancel <\/b>auf den Wert True <\/b>ein. Damit können wir mit der Escape<\/b>-Taste die Ereignisprozedur cmdCancel_Click <\/b>auslösen.<\/p>\n Standardmäßig kann man in einem Formular wie frmMitgliederDetails mit den Navigationsschaltflächen zum ersten, zum vorherigen, zum nächsten oder zum letzten Datensatz der Datensatzquelle wechseln – oder auch zu einem neuen, leeren Datensatz.<\/p>\n Beim Öffnen des Formulars zum Anlegen eines neuen Datensatzes enthält die Datenquelle des Formulars nur den neuen Datensatz, beim Öffnen zum Bearbeiten eines Datensatzes nur den zu bearbeitenden Datensatz. Wir können jedoch beim Bearbeiten eines vorhandenen Datensatzes oder nach der Eingabe der ersten Daten für einen neuen Datensatz durch wiederholtes Betätigen der Tab- oder Eingabetaste alle Steuerelemente durchlaufen und würden nach dem letzten Steuerelement der Aktivierreihenfolge in einem neuen, leeren Datensatz landen.<\/p>\n Um das zu verhindern, stellen wir die Eigenschaft Zyklus <\/b>auf Aktueller Datensatz <\/b>ein. Auf diese Weise landet der Fokus nach dem Verlassen des letzten Steuerelements der Aktiviereihenfolge wieder beim ersten Steuerelement, ohne den Datensatz zu verlassen.<\/p>\n Der Benutzer kann das Formular frmMitgliederDetails <\/b>nun zum Anlegen eines neuen Datensatzes öffnen. Wenn er ohne das Anlegen eines Datensatzes auf die OK<\/b>-Schaltfläche klickt, wird das Formular ausgeblendet, die aufrufende Prozedur des Formulars frmMitgliederUebersicht <\/b>erzeugt dann aber einen Fehler in der Zeile, welche die ID des neuen Datensatzes ermitteln soll:<\/p>\n Solche Fehler wollen wir verhindern. Das gelingt am einfachsten, wenn wir die Zeile wie folgt ändern:<\/p>\n Eleganter wäre es aber, wenn wir die OK<\/b>-Schaltfläche cmdOK <\/b>überhaupt erst aktivieren, wenn der Benutzer Änderungen an dem neuen oder dem zu bearbeitenden Datensatz vorgenommen hat. Dazu stellen wir zunächst die Eigenschaft Aktiviert <\/b>dieser Schaltfläche auf den Wert Nein <\/b>ein. Rufen wir das Formular nun zum Bearbeiten eines vorhandenen oder neuen Datensatzes auf, ist die OK<\/b>-Schaltfläche zunächst deaktiviert (siehe Bild 12).<\/p>\n Bild 12: Formular mit deaktivierter OK-Schaltfläche<\/span><\/b><\/p>\n Nun müssen wir nur noch dafür sorgen, dass die Schaltfläche aktiviert wird, wenn der Benutzer eine Änderung durchgeführt hat. Dies registrieren wir über die Ereigniseigenschaft Bei Geändert<\/b>, für die wir die folgende Ereignisprozedur hinterlegen:<\/p>\n Theoretisch könnten wir auch noch dafür sorgen, dass die Schaltfläche wieder deaktiviert wird, wenn der Benutzer die Änderung mit der Escape<\/b>-Taste rückgängig macht. Dazu würden wir die folgende Prozedur nutzen, die wir für das Ereignis Bei Rückgängig <\/b>hinterlegen:<\/p>\n Diese wird auch ausgelöst, allerdings hat das keine Auswirkung mehr, denn mit der Escape<\/b>-Taste feuert auch die Prozedur cmdCancel_Click<\/b>, was die Änderungen zurücksetzt und das Formular schließt.<\/p>\n Normalerweise speichert Access einen Datensatz, wenn dieser mit einem Formular eingegeben wurde und man das Formular dann schließt. Es gibt jedoch Bedingungen, unter denen dies misslingt. Der Datensatz wird dann einfach nicht gespeichert. Die Gründe dafür erläutern wir im Beitrag Formulare: Datensatz wird nicht gespeichert <\/b>(www.access-im-unternehmen.de\/1489<\/b>). <\/p>\n Der übliche Grund für dieses Verhalten ist, dass es Restriktionen im Datenmodell gibt, die das Speichern des Datensatzes verhindern. Wenn wir zum Beispiel die Eigenschaft Eingabe erforderlich <\/b>für das Feld Vorname <\/b>auf Ja <\/b>einstellen, kann ein Datensatz nur gespeichert werden, wenn dieses Feld einen Wert enthält, also nicht Null ist. Beim Schließen des Formulars über die Schaltfläche cmdOK <\/b>verwirft Access aber Änderungen an Datensätzen einfach, wenn Restriktionen im Datenmodell das Speichern verhindern. <\/p>\n Um dies zu unterbinden, müssen wir den Datensatz vor dem Schließen des Formulars manuell per Code speichern. Dazu ergänzen wir die Prozedur cmdOK_Click <\/b>wie folgt:<\/p>\n Wir rufen also den Befehl zum Speichern des Datensatzes auf. Wenn wir nun einen neuen Datensatz anlegen, erhalten wir immerhin eine entsprechende Fehlermeldung (siehe Bild 13).<\/p>\n Bild 13: Fehler beim Speichern eines Datensatzes ohne Erfüllen aller Restriktionen<\/span><\/b><\/p>\n Auch ohne eine umfangreiche Validierung zum Formular hinzufügen zu wollen: Die Restriktionen des Datenmodells müssen wir einhalten und wir wollen den Benutzer auch nicht mit scheinbar grundlos nicht gespeicherten neuen Datensätzen verwirren. Also fügen wir noch ein paar Zeilen Code hinzu, damit der Benutzer die Eingabe des Datensatzes korrekt abschließen kann. Diesen erläutern wir in dem oben genannten Beitrag, aber der Vollständigkeit halber nochmal die Prozedur für das Ereignis Beim Klicken <\/b>der Schaltfläche cmdOK<\/b> (siehe Listing 6).<\/p>\n Listing 6: Verhindern, dass der Datensatz bei Verletzungen der Restriktionen nicht gespeichert wird<\/span><\/b><\/p>\n Hier speichern wir mit RunCommand acCmdSaveRecord <\/b>den aktuellen Datensatz, was bei Verletzen einer Restriktion zu einem Fehler führt. Bei Feldern, die nicht leer sein dürfen, aber leer sind, wird der Fehler mit der Nummer 3314 <\/b>ausgelöst, bei Verletzen der Gültigkeitsregeln auf Tabellenebene der Fehler 3316<\/b>.<\/p>\n In beiden Fällen nutzen wir zwei im oben genannten Beitrag vorgestellte Hilfsfunktionen aus, welche aus der Fehlermeldung das Feld ermitteln, dessen Restriktion verletzt wurde und das Steuerelement suchen, das an dieses Feld gebunden ist – auf diese Weise können wir dieses Steuerelement nach dem Anzeigen der Fehlermeldung direkt selektieren.<\/p>\n Nur wenn kein Fehler ausgelöst wurde und die Variable lngErrorNumber <\/b>den Wert 0 <\/b>aufweist, wird das Formular geschlossen.<\/p>\n Die Suchfunktion haben wir so gestaltet, wie wir sie für funktional halten: Man gibt einen Suchbegriff ein, der in allen Feldern mit Textinhalten gesucht wird, und zwar als Bestandteil des Textes. Der gesuchte Text kann also an beliebiger Stelle innerhalb der Felder eines Datensatzes vorkommen.<\/p>\n Hier gibt es noch Varianten:<\/p>\n Davon abgesehen werden die Daten im Unterformular in der Datenblattansicht angezeigt, die ihrerseits einige Möglichkeiten zum Filtern anbietet (siehe Bild 14).<\/p>\n<\/p>\nÜbersichtsformular programmieren<\/h2>\n
![\"Erstellen](\"..\/fileadmin\/_temp_\/2024_02\/pic_1488_002.png\")
<\/p>\nDetails anzeigen per Doppelklick<\/h2>\n
![\"Ereignis](\"..\/fileadmin\/_temp_\/2024_02\/pic_1488_003.png\")
<\/p>\nPrivate Sub <\/span>MitgliedID_DblClick(Cancel As Integer<\/span>)\r\n Call<\/span> EditDetails\r\nEnd Sub<\/span><\/pre>\nPrivate Sub <\/span>EditDetails()\r\n Dim <\/span>strForm As String<\/span>\r\n strForm = \"frmMitgliederDetails\"\r\n DoCmd.OpenForm strForm, WindowMode:=acDialog, WhereCondition:=\"MitgliedID = \" & Me!MitgliedID, DataMode:=acFormEdit\r\n If <\/span>IstFormularGeoeffnet(strForm) Then<\/span>\r\n Me.Requery\r\n DoCmd.Close acForm, Me.Name\r\n End If<\/span>\r\nEnd Sub<\/span><\/pre>\nHauptformular programmieren<\/h2>\n
![\"Das](\"..\/fileadmin\/_temp_\/2024_02\/pic_1488_004.png\")
<\/p>\nFlexible Größe des Übersichtsformulars<\/h2>\n
Design der Schaltflächen<\/h2>\n
![\"Hinzufügen](\"..\/fileadmin\/_temp_\/2024_02\/pic_1488_005.png\")
<\/p>\nEreignisprozeduren im Übersichtsformular<\/h2>\n
Private Sub <\/span>cmdOK_Click()\r\n DoCmd.Close acForm, Me.Name\r\nEnd Sub<\/span><\/pre>\nSuchfunktion programmieren<\/h2>\n
Private Sub <\/span>txtSearch_Change()\r\n Dim <\/span>strSearch As String<\/span>\r\n Dim <\/span>strFilter As String<\/span>\r\n strSearch = Me!txtSearch.Text\r\n If <\/span>Not<\/span> Len<\/span>(strSearch) = 0 Then<\/span>\r\n strFilter = strFilter & \"OR Vorname LIKE ''*\" & strSearch & \"*''\"\r\n strFilter = strFilter & \"OR Nachname LIKE ''*\" & strSearch & \"*''\"\r\n strFilter = strFilter & \"OR Strasse LIKE ''*\" & strSearch & \"*''\"\r\n strFilter = strFilter & \"OR PLZ LIKE ''*\" & strSearch & \"*''\"\r\n strFilter = strFilter & \"OR Ort LIKE ''*\" & strSearch & \"*''\"\r\n strFilter = strFilter & \"OR EMail LIKE ''*\" & strSearch & \"*''\"\r\n strFilter = strFilter & \"OR Telefon LIKE ''*\" & strSearch & \"*''\"\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 Me!sfmMitgliederUebersicht.Form.Filter = strFilter\r\n Me!sfmMitgliederUebersicht.Form.FilterOn = True<\/span>\r\n Else<\/span>\r\n Me!sfmMitgliederUebersicht.Form.FilterOn = False<\/span>\r\n End If<\/span>\r\nEnd Sub<\/span><\/pre>\n![\"Die](\"..\/fileadmin\/_temp_\/2024_02\/pic_1488_008.png\")
<\/p>\nNeuen Datensatz hinzufügen<\/h2>\n
Private Sub <\/span>cmdAdd_Click()\r\n Dim <\/span>strForm As String<\/span>\r\n Dim <\/span>lngID As Long<\/span>\r\n strForm = \"frmMitgliederDetails\"\r\n DoCmd.OpenForm strForm, WindowMode:=acDialog, DataMode:=acFormAdd\r\n If <\/span>IstFormularGeoeffnet(strForm) Then<\/span>\r\n lngID = Forms(strForm)!MitgliedID\r\n DoCmd.Close acForm, strForm\r\n Me!sfmMitgliederUebersicht.Form.Requery\r\n Me!sfmMitgliederUebersicht.Form.Recordset.FindFirst \"MitgliedID = \" & lngID\r\n End If<\/span>\r\nEnd Sub<\/span><\/pre>\n![\"Das](\"..\/fileadmin\/_temp_\/2024_02\/pic_1488_006.png\")
<\/p>\nBearbeiten eines Datensatzes<\/h2>\n
Private Sub <\/span>cmdEdit_Click()\r\n Dim <\/span>lngID As Long<\/span>\r\n Dim <\/span>strForm As String<\/span>\r\n strForm = \"frmMitgliederDetails\"\r\n lngID = Nz(Me!sfmMitgliederUebersicht.Form.MitgliedID, 0)\r\n If <\/span>Not<\/span> lngEdit = 0 Then<\/span>\r\n DoCmd.OpenForm strForm, WindowMode:=acDialog, DataMode:=acFormEdit, WhereCondition:=\"MitgliedID = \" & lngID\r\n If <\/span>IstFormularGeoeffnet(strForm) Then<\/span>\r\n DoCmd.Close acForm, strForm\r\n Me!sfmMitgliederUebersicht.Form.Refresh\r\n End If<\/span>\r\n End If<\/span>\r\nEnd Sub<\/span><\/pre>\n![\"Bearbeiten](\"..\/fileadmin\/_temp_\/2024_02\/pic_1488_007.png\")
<\/p>\nLöschen eines Datensatzes<\/h2>\n
Private Sub <\/span>cmdDelete_Click()\r\n Dim <\/span>lngID As Long<\/span>\r\n Dim <\/span>lngPosition As Long<\/span>\r\n lngID = Nz(Me!sfmMitgliederUebersicht.Form.MitgliedID, 0)\r\n lngPosition = Me!sfmMitgliederUebersicht.Form.Recordset.AbsolutePosition\r\n If <\/span>Not<\/span> lngID = 0 Then<\/span>\r\n If MsgBox<\/span>(\"Soll der Datensatz wirklich gelöscht werden?\", vbOKCancel + vbExclamation, \"Löschbestätigung\") _\r\n = vbOK Then\r\n CurrentDb.Execute \"DELETE FROM tblMitglieder WHERE MitgliedID = \" & lngID, dbFailOnError\r\n Me!sfmMitgliederUebersicht.Form.Requery\r\n If <\/span>lngPosition > 0 Then<\/span>\r\n Me!sfmMitgliederUebersicht.Form.Recordset.AbsolutePosition = lngPosition - 1\r\n End If<\/span>\r\n End If<\/span>\r\n End If<\/span>\r\nEnd Sub<\/span><\/pre>\n\n
![\"Löschen](\"..\/fileadmin\/_temp_\/2024_02\/pic_1488_009.png\")
<\/p>\nDetailformular programmieren<\/h2>\n
![\"Entwurf](\"..\/fileadmin\/_temp_\/2024_02\/pic_1488_010.png\")
<\/p>\nPrivate Sub <\/span>cmdOK_Click()\r\n Me.Visible = False<\/span>\r\nEnd Sub<\/span><\/pre>\nPrivate Sub <\/span>cmdCancel_Click()\r\n Me.Undo\r\n DoCmd.Close acForm, Me.Name\r\nEnd Sub<\/span><\/pre>\nTypische Elemente ausblenden<\/h2>\n
OK per Eingabetaste<\/h2>\n
![\"Einstellen](\"..\/fileadmin\/_temp_\/2024_02\/pic_1488_011.png\")
<\/p>\nAbbrechen per Escape-Taste<\/h2>\n
Anzeigen anderer Datensätze verhindern<\/h2>\n
OK-Schaltfläche nur nach Änderung aktivieren<\/h2>\n
lngID = Forms(strForm)!MitgliedID<\/pre>\n
lngID = Nz(Forms(strForm)!MitgliedID, 0)<\/pre>\n
![\"Formular](\"..\/fileadmin\/_temp_\/2024_02\/pic_1488_012.png\")
<\/p>\nPrivate Sub <\/span>Form_Dirty(Cancel As Integer<\/span>)\r\n Me!cmdOK.Enabled = True<\/span>\r\nEnd Sub<\/span><\/pre>\nPrivate Sub <\/span>Form_Undo(Cancel As Integer<\/span>)\r\n Me!cmdOK.Enabled = False<\/span>\r\nEnd Sub<\/span><\/pre>\nDaten beim Schließen des Formulars speichern<\/h2>\n
Private Sub <\/span>cmdOK_Click()\r\n RunCommand acCmdSaveRecord\r\n Me.Visible = False<\/span>\r\nEnd Sub<\/span><\/pre>\n![\"Fehler](\"..\/fileadmin\/_temp_\/2024_02\/pic_1488_013.png\")
<\/p>\nPrivate Sub <\/span>cmdOK_Click()\r\n Dim <\/span>lngErrorNumber As Long<\/span>\r\n Dim <\/span>strErrorDescription As String<\/span>\r\n Dim <\/span>strField As String<\/span>\r\n Dim <\/span>ctl As <\/span>Control\r\n On Error Resume Next<\/span>\r\n RunCommand acCmdSaveRecord\r\n lngErrorNumber = Err.Number\r\n strErrorDescription = Err.Description\r\n On Error GoTo<\/span> 0\r\n Select Case lngErrorNumber\r\n Case <\/span>3314, 3316\r\n MsgBox<\/span> strErrorDescription, vbExclamation + vbOKOnly, \"Fehlende Eingabe\"\r\n strField = GetFieldFromErrorDescription(strErrorDescription)\r\n Set<\/span> ctl = GetBoundControlForField(Me, strField)\r\n ctl.SetFocus\r\n Case <\/span>0\r\n Case Else<\/span>\r\n MsgBox<\/span> strErrorDescription, vbExclamation + vbOKOnly, \"Fehler \" & lngErrorNumber\r\n End Select<\/span>\r\n If <\/span>lngErrorNumber = 0 Then<\/span>\r\n DoCmd.Close acForm, Me.Name\r\n End If<\/span>\r\nEnd Sub<\/span><\/pre>\nAnpassen der Suchfunktion<\/h2>\n
\n
![\"Eingebaute](\"..\/fileadmin\/_temp_\/2024_02\/pic_1488_014.png\")
<\/p>\n