<\/p>\n
Wenn Sie eine Anwendung programmieren, die ihre Daten nur über die Benutzeroberfläche ändert, sehen Sie die änderungen ja immer direkt in den entsprechenden Formularen und Steuerelementen. Aber manchmal erstellen, ändern oder löschen Sie Daten auch per Mausklick auf eine Schaltfläche und die dahinter liegende Prozedur erledigt den Rest. Gerade in der Entwicklungsphase möchen Sie dann natürlich schnell sehen, ob die Daten auch wirklich wie gewünscht editiert wurden. Dazu quält man sich dann meist durch die einzelnen Tabellen und prüft das Ergebnis. Wenn sich die Daten über verknüpfte Tabellen erstrecken, wird dies erst recht anstrengend. Aber nicht mit der Lösung, die wir in diesem Beitrag vorstellen!<\/b><\/p>\nBeispieldatenbank<\/h2>\n
Als Beispiel dient uns die oft verwendete Südsturm-Datenbank. Sie hat einige verknüpfte Tabellen, mit denen wir das eingangs erwähnte Problem des schwierigen Nachvollziehens geänderter oder neuer Daten leicht nachstellen können. Im ersten Beispiel wollen wir uns die verknüpften Tabellen in der Reihenfolge tblKunden<\/b>, tblBestellungen<\/b>, tblBestelldetails<\/b>, tblArtikel <\/b>ansehen (s. Bild 1).<\/p>\n
![\"Tabellen](\"..\/fileadmin\/_temp_\/2017_02\/pic_1078_001.png\")
<\/p>\n
Bild 1: Tabellen der Datenbank Südsturm<\/span><\/b><\/p>\n Am Ende dieses Artikels sollen Sie eine Lösung haben, mit der Sie verknüpfte Tabellen mit einer Tiefe von vier Hierarchieebenen auswählen und analysieren können.<\/p>\n Dazu erhalten Sie ein Formular, das vier Unterformulare enthält, von denen jedes die Daten einer von bis zu vier Tabellen anzeigt (s. Bild 2). Das oberste Unterformular soll beispielsweise die Daten der Tabelle tblKunden <\/b>anzeigen. Darunter finden Sie dann die Daten der Tabelle tblBestellungen<\/b>. Wenn der Benutzer nun auf einen der Datensätze der Tabelle tblKunden <\/b>klickt, soll das Unterformular mit den Daten der Tabelle tblBestellungen <\/b>nur die Datensätze anzeigen, die zum aktuellen Kunden gehören.<\/p>\n Bild 2: Die fertige Lösung<\/span><\/b><\/p>\n Darunter geht es weiter: Das dritte Unterformular zeigt alle Daten der Tabelle tblBestelldetails <\/b>an, die mit dem Datensatz des zweiten Unterformulars mit den Bestellungen verknüpft ist. Das vierte Unterformular liefert schließlich noch den dem Bestelldetail zugeordneten Datensatz der Tabelle tblArtikel<\/b>.<\/p>\n Der Clou bei der Lösung ist, dass Sie die Tabellen, deren Daten in den Unterformularen angezeigt werden, nicht fest in das Formular programmieren müssen, sondern dass es für alle beteiligten Tabellen, Primärschlüsselfelder und Fremdschlüsselfelder Kombinationsfelder zur Auswahl gibt. Auf diese Weise können Sie mit dem Formular nicht nur verschiedene Konfigurationen von verknüpften Tabellen untersuchen, sondern diese auch noch zur Laufzeit neu einstellen, um eine andere Konfiguration zu begutachten.<\/p>\n Nun wäre es natürlich aufwendig, immer wieder alle Eigenschaften einer Konfiguration neu einzugeben, wenn man diese einmal wechseln will oder das Formular gar in einer anderen Datenbank als der aktuellen einsetzen möchte. Deshalb können Sie verschiedene Konfigurationen speichern und diese immer wieder neu abrufen. Wenn Sie das Formular erstmalig öffnen, fragt dieses Sie gleich nach dem Namen der ersten anzulegenden Konfiguration. Diese wird dann nach dem öffnen des Formulars oben im Kombinationsfeld angezeigt.<\/p>\n Sie können nun mit den je nach Ebene zwei bis drei Kombinationsfeldern die Tabelle auswählen, die das entsprechende Unterformular anzeigen soll. Danach legen Sie zunächst für die obere Tabelle das Primärschlüsselfeld fest.<\/p>\n Damit das Formular weiß, welche Datensätze des zweiten Unterformulars zu dem im ersten Unterformular angezeigten Datensatz gehören, geben Sie für das zweite Unterformular das Fremdschlüsselfeld an, über das es mit den Datensätzen der übergeordneten Tabelle verknüpft ist.<\/p>\n Auf die gleiche Weise verfahren Sie mit den folgenden Kombinationsfeldern für Primär- und Fremdschlüsselfelder, bis Sie für das vierte Unterformular nur noch das Fremdschlüsselfeld angeben müssen.<\/p>\n Wenn Sie bereits mehrere Konfigurationen angelegt haben, können Sie diese über das Kombinationsfeld mit der Beschriftung Konfiguration<\/b> wechseln. Mit der Löschen<\/b>-Schaltfläche entfernen Sie die aktuell ausgewählte Konfiguration aus der Datenbank.<\/p>\n Auf den folgenden Seiten werden wir uns zunächst eine einfache, statische Variante dieser Lösung ansehen, um die Grundlagen der Vorgehensweise zu verdeutlichen. Im Anschluss schauen wir uns dann an, wie das Formular zur flexiblen Anzeige der Daten verknüpfter Tabellen programmiert wird.<\/p>\n Das Hauptformular dient zunächst nur als Container für die einelnen Unterformulare. Erstellen Sie also ein leeres Hauptformular und speichern Sie es unter dem Namen frmVerknuepfteTabellen<\/b>.<\/p>\n Gleich fügen wir die einzelnen Unterformulare und die Funktion in Form von VBA-Code hinzu.<\/p>\n Die Unterformulare sind prinzipiell alle gleich aufgebaut. Wir schauen uns dies am Beispiel des Formulars sfmKunden<\/b> an, welches die Datensätze der Tabelle tblKunden <\/b>abbilden soll. Dazu legen Sie ein neues, leeres Formular an und stellen als Datenherkunft die Tabelle tblKunden <\/b>ein. Gegebenenfalls können Sie auch eine Abfrage erstellen, welche beispielsweise die Kunden nach dem Feld Firma <\/b>sortiert. Danach fügen Sie wie in Bild 3 alle Felder der Datenherkunft zum Detailbereich der Entwurfsansicht der Tabelle hinzu. Stellen Sie die Eigenschaft Standardansicht<\/b> auf Datenblatt <\/b>ein. Speichern Sie das Formular dann etwa unter dem Namen sfmKunden<\/b> und schließen Sie es.<\/p>\n Bild 3: Entwurf des Unterformulars für die Anzeige der Kundendatensätze<\/span><\/b><\/p>\n Dann öffnen Sie das Hauptformular in der Entwurfsansicht und ziehen das Unterformular sfmKunden <\/b>aus dem Navigationsbereich in den Detailbereich des Hauptformulars. Das Ergebnis sieht etwa wie in Bild 4 aus.<\/p>\n Bild 4: Das Hauptformular mit einem ersten Unterformular<\/span><\/b><\/p>\n Auf die gleiche Weise gehen Sie mit den Unterformularen für die Tabellen tblBestellungen<\/b>, tblBestelldetails <\/b>und tblArtikel <\/b>vor: Legen Sie diese an, fügen Sie Datenherkunft und Felder hinzu und ziehen Sie diese dann untereinander in das Formular frmVerknuepfteTabellen<\/b>. Mit allen vier Unterformularen sieht das Formular dann in der Datenblattansicht wie in Bild 5 aus. Die vier Unterformulare zeigen hier jeweils alle Datensätze ihrer Datenquelle an.<\/p>\n Bild 5: Das Hauptformular mit allen vier Unterformularen<\/span><\/b><\/p>\n Das ist natürlich schon praktischer als wenn man immer alle Tabellen einzeln öffnen muss. Allerdings wollen wir noch einen entscheidenden Schritt weitergehen: Wenn der Benutzer nun auf einen der Einträge der Tabelle tblKunden <\/b>im Unterformular sfmKunden <\/b>klickt, soll das nächste Unterformular nur noch die Datensätze der Tabelle tblBestellungen <\/b>anzeigen, die über das Feld KundeID<\/b> mit dem ausgewählten Kundendatensatz verknüpft sind.<\/p>\n Dazu müssen wir ein paar Zeilen VBA-Code hinzufügen. Wir machen das erstmal auf die einfachste Weise. Das Ereignis, das wir benötigen, heißt Beim Anzeigen <\/b>und wird immer dann ausgelöst, wenn ein neuer Datensatz in einem Formular den Fokus erhält.<\/p>\n Diesem weisen wir nun eine Ereignisprozedur zu, welche die Datensätze des untergeordneten Unterformulars so filtert, dass es nur noch die mit dem aktuell ausgewählten Datensatz verknüpften Datensätze anzeigt.<\/p>\n Der Plan ist also, eine Prozedur wie die folgende auszulösen, die eine Referenz auf das darunter angeordnete Formular speichert und für diese die Filter<\/b>-Eigenschaft mit einem entsprechenden Filter-Ausdruck belegt:<\/p>\n Wenn wir das Formular nun öffnen, erhalten wir allerdings die Fehlermeldung aus Bild 6. Das ist etwas überraschend: Wir haben das Unterformular doch korrekt referenziert Nach dem Akzeptieren des Fehlers mit Beenden schauen wir uns an, ob wir das Unterformular über den Direktbereich referenzieren können. Dazu setzen wir den folgenden Befehl ab:<\/p>\n Bild 6: Fehlermeldung beim öffnen des Formulars<\/span><\/b><\/p>\n Vom Direktfenster aus können wir also auf das Unterformular zugreifen. Also scheint es eine Frage des Timings zu sein. Das Ereignis Beim Anzeigen <\/b>wird ja nicht nur dann ausgelöst, wenn der Benutzer den Datensatz wechselt, sondern auch direkt nach dem öffnen des Formulars. Offensichtlich ist das Unterformular sfmBestellungen<\/b> also noch nicht geladen, wenn das Ereignis Beim Anzeigen <\/b>des Unterformulars sfmKunden <\/b>ausgelöst wird.<\/p>\n Wie können wir dieses Verhalten beeinflussen In welcher Reihenfolge werden die Unterformulare überhaupt geladen, wenn sich mehrere Unterformulare im gleichen Hauptformular befinden Dies wollen wir experimentell prüfen, indem wir ein neues, leeres Hauptformular erstellen und diesmal zuerst das Unterformular sfmBestellungen <\/b>in den Entwurf des Formulars ziehen und erst dann sfmKunden<\/b>.<\/p>\n Den Code brauchen Sie nicht erneut einzugeben, da er sich ja in dem Unterformular sfmKunden <\/b>befindet. Wenn Sie das Formular nun öffnen, erscheint keine Fehlermeldung und das Unterformular sfmBestellungen <\/b>zeigt nur die Bestellungen an, die zum aktuell im Unterformular sfmKunden <\/b>ausgewählten Datensatz gehören.<\/p>\n Wir wollen uns allerdings nicht auf solch willkürliche Faktoren wie die Reihenfolge des Hinzufügens von Steuerelementen verlassen. Außerdem ist es ja auch kein erklärtes Ziel, gleich beim Anzeigen des Formulars alle Daten gleich auf den im ersten Formular ausgewählten Datensatz zu konzentrieren.<\/p>\n Schließlich ist es ohnehin kein guter Programmierstil, ein Unterformular von einem anderen Unterformular über den Umweg des Hauptformulars zu referenzieren. Und wenn wir die hier verwendete Prozedur auch für die verknüpften Tabellen in den übrigen Unterformularen nutzen wollen, verteilt sich der Code schnell über mehrere Formulare und wird unübersichtlich.<\/p>\n Daher wollen wir sämtlichen Code gleich ins Hauptformular überführen, von wo wir die Unterformulare referenzieren und die Ereignisprozeduren für das Ereignis Beim Anzeigen <\/b>der verschiedenen Unterformulare implementieren wollen (s. Listing 1). Also löschen wir zunächst die Ereignisprozedur Form_Current <\/b>aus dem Unterformular sfmKunden<\/b>.<\/p>\n Listing 1: Code, um die Unterformulare nacheinander zu filtern<\/span><\/b><\/p>\n Danach legen Sie eine Variable für das Unterformular sfmKunden <\/b>im Klassenmodul des Hauptformulars frmVerknuepfteTabellen <\/b>an:<\/p>\n Damit diese gefüllt wird, implementieren wir das Ereignis Beim Laden <\/b>des Hauptformulars wie folgt:<\/p>\n Nun müssen wir nur noch das Ereignis Beim Anzeigen <\/b>des Unterformulars implementieren. Dazu wählen Sie im Klassenmodul des Hauptformulars aus dem linken Kombinationsfeld den Eintrag frm_sfmKunden <\/b>aus und aus dem rechten Kombinationsfeld den Eintrag OnCurrent<\/b>. Dies legt die neue Ereignisprozedur an, die Sie wie folgt ergänzen:<\/p>\n Das war es schon – wir haben den kompletten Code im Hauptformular und können so steuern, dass das Unterformular sfmBestellungen <\/b>nur die Bestellungen anzeigt, die dem im Unterformular sfmKunden <\/b>ausgewählten Datensatz zugeordnet sind.<\/p>\n Eine Voraussetzung ist dafür zu erfüllen, damit Sie die Ereignisprozeduren der untergeordneten Formulare implementieren können: Diese müssen jeweils ein eigenes Klassenmodul enthalten.<\/p>\n Dies stellen Sie am schnellsten über den Wert Ja <\/b>für die Eigenschaft Enthält Modul <\/b>des jeweiligen Formulars ein.<\/p>\n <\/p>\n Damit alle Unterformulare jeweils die Daten des folgenden Unterformulars filtern, benötigen wir für jedes Unterformular die bereits vorgestellten Code-Zeilen.<\/p>\n Wir deklarieren also für alle vier Unterformulare jeweils eine Form<\/b>-Variable, von denen allerdings nur die ersten drei mit dem Schlüsselwort WithEvents <\/b>ausgestattet werden müssen – das letzte Unterformular mit den Einträgen der Tabelle tblArtikel <\/b>soll ja beim Anklicken keine weiteren Datensätze mehr filtern.<\/p>\n Die Prozedur Form_Load <\/b>des Hauptformulars setzt dann die Verweise für die vier Form<\/b>-Variablen auf die entsprechenden Form<\/b>-Elemente in den Unterformular-Steuerelementen. Für die ersten drei legt sie außerdem fest, dass in diesem Klassenmodul auch nach Implementierungen des Ereignisses OnCurrent <\/b>gesucht werden soll.<\/p>\n Schließlich fehlen noch die Implementierungen der Ereignisse, die jeweils ähnlich aufgebaut sind, aber sich auf die verschiedenen Unterformulare beziehen. frm_sfmKunden_Current <\/b>stellt den Filter von frm_sfmBestellungen <\/b>auf den aktuellen Kunden ein, frm_sfmBestellungen_Current <\/b>den Filter von frm_sfmBestelldetails <\/b>und frm_sfmBestelldetails_Current <\/b>den von frm_sfmArtikel<\/b>.<\/p>\n Warum haben wir die Formular-Variablen nicht einfach genauso benannt wie die Unterformulare Wir haben es zunächst ausprobiert, aber Access kommt anscheinend nicht klar, wenn es einerseits ein Unterformular-Steuerelement und andererseits eine mit WithEvents <\/b>deklarierte Variable mit dem gleichen Namen gibt.<\/p>\n Wir haben bei diesem Versuch reproduzierbar einen Absturz von Access verursacht, als wir versucht haben, das Ereignis Beim Anzeigen <\/b>für das Element sfm_Bestellungen <\/b>anzulegen. Aus diesem Grund haben wir allen Form<\/b>-Variablen noch das Präfix frm_ <\/b>vorangestellt.<\/p>\n Nach dem Wechsel in die Formularansicht funktioniert das Formular wie gewünscht. Wenn Sie einen der Einträge des obersten Unterformulars mit den Daten der Tabelle tblKunden <\/b>anklicken, zeigt das nächste Unterformular die dazu gehörende Bestellung, das nächste die zur Bestellung gehörenden Bestelldetails und das letzte den Artikel zum jeweiligen Bestelldetail an (s. Bild 7).<\/p>\n Bild 7: Gefilterte Unterformulare<\/span><\/b><\/p>\n Nun ist es allerdings etwas umständlich, für jede neue Konstellation ein neues dieser Formulare samt Unterformularen erstellen zu müssen. Also machen wir das Formular etwas flexibler, indem wir dem Benutzer die Auswahl der Tabellen und der Verknüpfungsfelder ermöglichen.<\/p>\n Das ist allerdings etwas komplizierter als nur ein paar Kombinationsfelder zur Auswahl der beteiligten Tabellen und Felder hinzuzufügen und die dort gewählten Einträge dann zur Laufzeit in den Code zu integrieren. Schließlich mussten wir ja jedes Unterformular separat erstellen und haben dort auch die Datenherkunft festgelegt und die verschiedenen Felder zum Detailbereich hinzugefügt. Auch dies müssen wir berücksichtigen, wenn wir vier Unterformulare dynamisch mit den Daten verschiedener Tabellen füllen wollen.<\/p>\n Wir müssen also statt einiger per Drag and Drop aus der Feldliste in den Entwurf gezogener Felder einige ungebundene Textfelder anlegen, die wir erst zur Laufzeit mit den Feldern der angegebenen Tabelle oder Abfrage füllen.<\/p>\n Außerdem sollten wir uns überlegen, wie aufwändig auch das Auswählen der Tabellen und Verknüpfungsfelder noch ist, wenn der Benutzer diesen Vorgang mehrfach wiederholen muss. Es ist ja anzunehmen, dass der Benutzer länger an einem bestimmten Algorithmus zum ändern von Daten arbeitet und das Formular mit seiner aktuellen Konfiguration auch häufiger benötigt – vielleicht auch noch später, wenn Fehler auftauchen oder änderungen vorzunehmen sind. Für diesen Fall sorgen wir vor und legen eine Tabelle an, in welcher der Benutzer die Konfiguration speichern kann.<\/p>\n Wir beginnen mit dem flexiblen Unterformular. Die Verwendung eines flexiblen Unterformulars hat gegenüber den mit einer festen Datenherkunft versehenen Unterformularen den Vorteil, dass wir nur eines davon benötigen, das wir mehrfach in das Hauptformular einbetten und mit verschiedenen Daten füttern (s. Bild 8).<\/p>\n Bild 8: Flexibles Unterformular<\/span><\/b><\/p>\n Dieses Formular können wir natürlich nicht mit einer festen Datenherkunft und entsprechend gebundenen Feldern versehen, sondern wir lassen die Eigenschaft Datenherkunft <\/b>leer und fügen einfach zehn Textfelder hinzu, denen wir die Namen txt01 <\/b>bis txt10 <\/b>geben. Die dabei automatisch hinzugefügten Bezeichnungsfelder benennen wir mit den Namen lbl01 <\/b>bis lbl10<\/b>. Diese Benennung ist notwendig, weil wir diese Steuerelemente später mit den Namen der Felder füllen wollen. Die Bezeichnungsfelder werden zwar in der Datenblattansicht, die wir mit der Eigenschaft Standardansicht <\/b>festlegen, nicht angezeigt, aber deren Beschriftungen werden für die Spaltenüberschriften herangezogen. Ganz wichtig ist es, dass Sie für dieses Formular die Eigenschaft Enthält Modul <\/b>auf den Wert Ja <\/b>einstellen, da wir sonst, wie weiter oben bereits beschrieben, keine Ereignisse dieses Formulars im Klassenmodul des übergeordneten Formulars implemenieren können (genau genommen können wir diese natürlich implementieren, aber sie werden dann niemals ausgelöst).<\/p>\n Das waren schon alle Schritte, die für die Erstellung des Unterformulars sfmTabellen <\/b>nötig sind. Kein Wunder: Die Ereignisprozeduren für dieses Formular landen ja auch alle im übergeordneten Formular.<\/p>\n Bevor wir zur Gestaltung und Programmierung des Hauptformulars kommen, benötigen wir noch eine Tabelle namens tblKonfigurationen<\/b>. Wie eingangs erwähnt, wollen wir ja die einzelnen Konfigurationen speichern und wieder auswählen können. Für das Speichern der anfallenden Daten nutzen wir unter Access natürlich eine Tabelle.<\/p>\n Diese sieht in der Entwurfsansicht wie in Bild 9 aus und enthält Felder zum Speichern aller beim Definieren einer Konfiguration anfallenden Daten – die Tabellen für das erste bis vierte Unterformular, die Primärschlüsselfelder für die ersten drei Unterformulare und die Fremdschlüsselfelder für die unteren drei Unterformulare.<\/p>\n Bild 9: Tabelle zum Speichern der Konfigurationen<\/span><\/b><\/p>\n Das Hauptformular heißt frmTabellen <\/b>und ist an die soeben vorgestellte Tabelle tblKonfigurationen <\/b>gebunden. Der obere Bereich dieses Formulars sieht im Entwurf so wie in Bild 10 aus.<\/p>\n Bild 10: Entwurf des oberen Bereichs des Formulars frmTabellen<\/span><\/b><\/p>\n Beginnen wir mit den Datensatzherkünften für die Kombinationsfelder. Die vier Kombinationsfelder zur Auswahl der im jeweiligen Unterformular anzuzeigenden Tabelle heißen cboTabelle1 <\/b>bis cboTabelle4<\/b> und enthalten alle die gleiche Abfrage als Datensatzherkunft. Diese zeigt Bild 11 in der Entwurfsansicht. Diese Abfrage verwendet die Systemtabelle MSysObjects <\/b>als Datenherkunft, die wiederum alle Access-Objekte enthält. Mit dem Kriterium für das erste Feld klammern wir System- und versteckte Tabellen aus dem Abfrageergebnis aus, mit dem Kriterium für das Feld Type <\/b>lassen wir nur Tabellen verschiedener Arten sowie Abfragen zu. Diese Abfrage legen Sie als Datensatzherkunft für die vier Kombinationsfelder cboTabelle1 <\/b>bis cboTabelle4 <\/b>an.<\/p>\n Bild 11: Datensatzherkunft der Kombinationsfelder zur Auswahl der in den Unterformularen anzuzeigenden Tabellen<\/span><\/b><\/p>\n Die Kombinationsfelder cboPrimaerschluessel1 <\/b>bis cboPrimaerschluessel3 <\/b>und cboFremdschluessel2 <\/b>bis cboFremdschluessel4 <\/b>sollen die in den mit den Kombinationsfeldern cboTabellen1 <\/b>bis cboTabellen4 <\/b>ausgewählten Tabellen enthaltenen Felder zur Auswahl anbieten. Dazu sind zwei Schritte nötig: Erstens müssen wir die Eigenschaft Herkunftsart <\/b>für diese Kombinationsfelder auf den Wert Feldliste <\/b>einstellen. Zweitens müssen wir dafür sorgen, dass nach Auswahl eines Eintrags in einem der Kombinationsfelder cboTabellen1<\/b> bis cboTabellen4 <\/b>die Datensatzherkunft der Kombinationsfelder mit dem Primärschlüsselfeldern und Fremdschlüsselfeldern auf den Namen der soeben ausgewählten Tabelle eingestellt wird.<\/p>\n Dazu legen wir etwa für das Kombinationsfeld cboTabellen1 <\/b>eine Ereignisprozedur an, die durch das Ereignis Nach Aktualisierung <\/b>ausgelöst wird und wie folgt aussieht:<\/p>\n Diese Prozedur stellt die Datensatzherkunft auf den Wert Nz(Me!cboTabellen1) <\/b>ein, was dazu führt, dass entweder der Name der ausgewählten Tabelle oder, falls das Kombinationsfeld geleert wurde, kein Wert im Kombinationsfeld cboPrimaer-schlues-selfeld1 <\/b>landet. Das Kombinationsfeld cboPrimaerschluesselfeld1 <\/b>wird geleert, erhält den Fokus und wird mit der Methode DropDown <\/b>aufgeklappt.<\/p>\n Außerdem stellt diese Prozedur die Datenherkunft des Unterformulars sfm-Tabelle1 <\/b>auf diese Tabelle ein, damit dieses die entsprechenden Daten anzeigt. Das noch fehlende Unterformular ziehen Sie einfach per Drag and Drop aus dem Navigationsbereich in den Detailbereich der Entwurfsansicht des Hauptformulars.<\/p>\n Stellen Sie die Eigenschaft Horizontaler Anker <\/b>auf Beide <\/b>ein, damit sich die Größe beim Anpassen der Größe des Hauptformulars ebenfalls ändert.<\/p>\n Die Prozedur cboTabellen1_AfterUpdate <\/b>hält schließlich noch einen Aufruf einer Prozedur namens UnterformularEinstellen <\/b>bereit, der sie einen Verweis auf das Unterformular sfmTabellen1 <\/b>übermittelt. Diese Prozedur schauen wir uns weiter unten an.<\/p>\n Die Nach Aktualisierung<\/b>-Ereignisprozeduren der übrigen Kombinationsfelder zur Auswahl der Tabellen sehen ähnlich aus. Sie enthalten allerdings an die vorhandenen, mit einer Datensatzherkunft zu füllenden Kombinationsfelder angepasste Anweisungen – so soll die Prozedur für das Kombinationsfeld cboTabellen2 <\/b>natürlich nicht nur das Primärschlüssel-Kombinationsfeld, sondern auch noch das Fremdschlüssel-Kombinationsfeld füllen:<\/p>\n Die soeben erwähnte Prozedur UnterformularEinstellen<\/b> finden Sie in Listing 2. Sie sorgt dafür, dass die Textfelder im Unterformular an die entsprechenden Felder der dynamisch hinzugefügten Datenherkunft gebunden werden. Außerdem müssen natürlich auch die Bezeichnungsfelder auf die entsprechenden Feldnamen eingestellt werden.<\/p>\n Listing 2: Einstellen der Steuerelemente in den Unterformularen<\/span><\/b><\/p>\n Das Formular weist zunächst das über die gleichnamige Eigenschaft ermittelte Recordset <\/b>des mit sfm <\/b>übergebenen Unterformular-Objekts der Variaben rst <\/b>zu. Dann durchläuft sie in einer For Each<\/b>-Schleife alle Field<\/b>-Objekte dieses Recordsets. Dabei prüft sie jeweils, ob die Zählervariable i <\/b>bereits den Wert 10 <\/b>erreicht hat. Dies ist notwendig, da das Unterformular ja nur zehn Textfelder zur Anzeige von Feldern der Datenherkunft enthält. Solange der Wert 10 <\/b>noch nicht erreicht ist, stellt die Prozedur die Eigenschaft ColumnHidden <\/b>des Textfeldes auf den Wert False <\/b>ein, damit die zu diesem Textfeld gehörende Spalte der Datenblattansicht eingeblendet wird.<\/p>\n Anderenfalls wird die Schleife an dieser Stelle verlassen. Sollten zuvor einmal nicht alle Spalten genutzt worden sein, wurden diese nämlich ausgeblendet und müssen nun wieder eingeblendet werden. Die folgende Anweisung stellt die Eigenschaft ControlSource<\/b>, also den Steuerelementinhalt, auf das aktuell durchlaufene Feld des Recordsets ein. Schließlich erhält noch das Bezeichnungsfeld den Namen des Felds als Beschriftung. Während dieser drei Anweisungen greift die Prozedur über einen Ausdruck auf die Textfelder zu, der sich aus der Zeichenkette txt <\/b>sowie der Variablen i <\/b>im Format „00“<\/b> zusammensetzt. Damit können leicht in einer Schleife die Steuerelemente txt01 <\/b>bis txt10 <\/b>und lbl01 <\/b>bis lbl10 <\/b>durchlaufen werden.<\/p>\n Nun kann es allerdings geschehen, dass die Tabelle weniger als zehn Felder enthält. In diesem Fall sollen die übrigen Spalten natürlich nicht leer bleiben, sondern diese sollen ausgeblendet werden. Daher prüfen wir mit einer If…Then<\/b>-Bedingung im Anschluss einfach, ob die Laufvariable i <\/b>kleiner als 10 <\/b>ist, was darauf hindeutet, dass die Tabelle weniger als zehn Felder aufweist. Dann folgt eine weitere For…Next<\/b>-Schleife, die diesmal die Variable i <\/b>als Startwert und den Wert 10 <\/b>als Endwert verwendet sowie die Variable j <\/b>als Laufvariable.<\/p>\n Wenn die Tabelle beispielsweise sechs Felder enthält, hat i<\/b> zu diesem Zeitpunkt den Wert 6<\/b>, der dann aber gleich auf 7 <\/b>erhöht wird, damit die Schleife den richtigen Einstiegspunkt erhält. Dann durchläuft die Prozedur die For…Next<\/b>-Schleife für die Werte von 7 <\/b>bis 10 <\/b>und stellt innerhalb der Schleife die Eigenschaft ColumnHidden <\/b>auf den Wert True<\/b>, um die Spalte auszublenden. Außerdem wird der Steuerelementinhalt geleert und die Beschriftung des Bezeichnungsfeldes auf eine leere Zeichenkette eingestellt.<\/p>\n Dieser Vorgang wird für alle Unterformulare durchgeführt.<\/p>\n Wenn das Hauptformular geladen wird, sollen in der Ereignisprozedur Form_Load <\/b>einige vorbereitende Aktionen durchgeführt werden (s. Listing 3). Hier gehen wir zunächst davon aus, dass das Formular geöffnet wird, während noch keine Konfigurationen in der Tabelle tblKonfigurationen <\/b>gespeichert sind. Daher wollen wir den Benutzer nach dem Namen der ersten anzulegenden Konfiguration fragen und zeigen dazu eine InputBox <\/b>an, welche die gewünschten Informationen aufnimmt. Hat der Benutzer eine Bezeichnung eingegeben, legt die Prozedur einen neuen Datensatz in der Tabelle tblKonfigurationen <\/b>an und speichert dort auch bereits die angegebene Bezeichnung. Danach ermittelt die Prozedur den Wert des Feldes KonfigurationID <\/b>des neuen Datensatzes und aktualisiert die Datenherkunft des Formulars, bevor es das Recordset des Hauptformulars auf den soeben neu erstellten Datensatz einstellt. Sollte der Benutzer keine neue Bezeichnung eingegeben haben, wird das Formular geschlossen.<\/p>\n Listing 3: Ereignisprozedur, die beim Laden des Hauptformulars ausgelöst wird<\/span><\/b><\/p>\n Anschließend ruft die Prozedur die Routine Unter-for-mu-lare-Aktualisieren <\/b>auf (siehe weiter unten) und nimmt danach einige Einstellungen für die Programmierung der Unterformulare vor. Für jedes dieser Unterformulare legen wir dazu eine Objektvariable im Kopf des Klassenmoduls an:<\/p>\n Danach weist die Prozdur jeder dieser Variablen das entsprechende Formular im Unterformular-Steuerelement zu und stellt die Eigenschaft Beim Anzeigen <\/b>(OnCurrent<\/b>) auf den Wert [Ereignisprozedur] <\/b>([Event Procedure]<\/b>) ein. Dadurch können wir dieses Ereignis für die jeweiligen Unterformulare im aktuellen Klassenmodul implementieren.<\/p>\n Nach dem Ereignis Form_Load <\/b>wird die für die Ereigniseigenschaft Beim Anzeigen <\/b>hinterlegte Prozedur Form_Current <\/b>ausgelöst:<\/p>\n Diese stellt das Kombinationsfeld cboKonfigurationen<\/b>, welches nicht nur die Auswahl einer Konfiguration erlauben, sondern auch den Namen der aktuellen Konfiguration anzeigen soll, auf den Datensatz ein, der gerade im Formular angezeigt wird. Danach ruft sie die Prozedur UnterformulareAktualisieren <\/b>auf, die Sie in Listing 4 finden.<\/p>\n Listing 4: Aktualisieren der Steuerelemente der Unterformulare<\/span><\/b><\/p>\n Die Prozedur UnterformulareAktualisieren <\/b>wird immer beim Anzeigen beziehungsweise Wechseln des aktuellen Datensatzes aufgerufen. Sie stellt die Eigenschaften Datensatzherkunft <\/b>der Kombinationsfelder und die Eigenschaft Datenherkunft <\/b>der Unterformulare auf die in den Steuerelementen cboTabellen1 <\/b>bis cboTabellen4 <\/b>gespeicherten Tabellen ein. Außerdem ruft die Prozedur noch für jedes Unterformular die bereits beschriebene Routine UnterformularEinstellen <\/b>auf, um die zur angegebenen Tabelle gehörenden Felder zu binden und anzuzeigen.<\/p>\n Wie oben angekündigt, wollen wir das Ereignis Beim Anzeigen <\/b>der Unterformulare nicht in den Unterformularen selbst implementieren, sondern gleich im Hauptformular. So ist der Code des gesamten Formulars samt Unterformularen in einem Klassenmodul. Außerdem können wir über die Objektvariablen Me<\/b>, sfm1<\/b>, sfm2<\/b>, sfm3 <\/b>und sfm4 <\/b>bequem auf die verschiedenen Formularinstanzen zugreifen.<\/p>\n Was aber soll nun geschehen, wenn ein neuer Datensatz in einem der Unterformulare sfm1 <\/b>bis sfm4 <\/b>angezeigt wird Wir wollen dafür sorgen, dass das nächste Unterformular so gefiltert wird, dass es nur noch die Datensätze anzeigt, deren Wert im Fremdschlüsselfeld mit dem Wert des Primärschlüsselfeldes des Datensatzes im auslösenden Formular übereinstimmt. Wenn das erste Unterformular also etwa die Kunden anzeigt und das zweite die Bestellungen, dann soll das zweite Formular nach Auswahl eines Kunden im ersten Formular nur noch die zu diesem Kunden gehörenden Bestellungen anzeigen.<\/p>\n Die Ereignisprozedur aus Listing 5 prüft dazu zunächst, ob überhaupt ein Primärschlüsselfeld und ein Fremdschlüsselfeld ausgewählt wurden. Dazu ermittelt es die Zeichenlänge und multipliziert die beiden Werte, wobei das Ergebnis einen Wert größer als 0 <\/b>liefern sollte.<\/p>\n Listing 5: Ereignis, das beim Anzeigen eines Datensatzes im Unterformular ausgelöst wird<\/span><\/b><\/p>\n Danach stellt die Prozedur die Eigenschaft Filter <\/b>für das Unterformular auf einen Wert ein, der sich aus dem Wert des Kombinationsfeldes cboFremdschluessel <\/b>(also dem Namen des Fremdschlüsselfeldes), einem Gleichheitszeichen und dem Wert des Primärschlüsselfeldes des übergeordneten Formulars zusammensetzt und etwa wie folgt aussieht:<\/p>\n Anschließend aktiviert sie den Filter durch Einstellen der Eigenschaft FilterOn <\/b>auf True<\/b>. Sollte eines der beiden Kombinationsfelder nicht gefüllt sein, wird der Filter schlicht und einfach geleert.<\/p>\n Wenn der Benutzer einen der anderen Einträge des Kombinationsfeldes cboKonfiguration <\/b>auswählt, soll die entsprechende Konfiguration auch im Formular angezeigt werden.<\/p>\n Dies erledigen wir mit der folgenden Prozedur, die durch das Ereignis Nach Aktualisierung <\/b>des Kombinationsfeldes cboKonfigurationen <\/b>ausgelöst wird:<\/p>\n Dies löst natürlich auch die Ereignisprozedur Form_Current <\/b>und die Beim Anzeigen<\/b>-Ereignisprozeduren der vier Unterformulare aus, wodurch die Konfiguration wenig später im Formular abgebildet wird. <\/p>\n Wenn Sie eine neue Konfiguration hinzufügen möchten, können Sie dies mit einem Klick auf die Schaltfläche cmdNeu<\/b> erledigen. Diese löst die Prozedur aus Listing 6 aus. Die Prozedur ermittelt zunächst per InputBox <\/b>die Bezeichnung für die neue Konfiguration und prüft, ob der Benutzer eine Zeichenkette eingegeben hat. Falls ja, trägt die Prozedur diese als neuen Datensatz in die Tabelle tblKonfiguration <\/b>ein und ermittelt den Primärschlüsselwert des neuen Datensatzes dieser Tabelle. Danach aktualisiert sie die Datenherkunft des aktuellen Formulars, um auch den neuen Datensatz anzeigen zu können. Schließlich sorgt der Aufruf der FindFirst<\/b>-Methode des Recordsets des Formulars für die Anzeige des neuen Datensatzes. Der Benutzer kann nun die Tabellen, Primärschlüsselfelder und Fremdschlüsselfelder auswählen.<\/p>\nDie fertige Lösung<\/h2>\n
![\"Die](\"..\/fileadmin\/_temp_\/2017_02\/pic_1078_007.png\")
<\/p>\nAuf geht“s!<\/h2>\n
Erstellen des Hauptformulars<\/h2>\n
Erstellen der Unterformulare<\/h2>\n
![\"Entwurf](\"..\/fileadmin\/_temp_\/2017_02\/pic_1078_002.png\")
<\/p>\nUnterformular in Hauptformular<\/h2>\n
![\"Das](\"..\/fileadmin\/_temp_\/2017_02\/pic_1078_003.png\")
<\/p>\nWeitere Unterformulare<\/h2>\n
![\"Das](\"..\/fileadmin\/_temp_\/2017_02\/pic_1078_004.png\")
<\/p>\nFunktion hinzufügen<\/h2>\n
Private Sub <\/span>Form_Current()\r\n Dim <\/span>frm As <\/span>Form\r\n Set<\/span> frm = Me.Parent!sfmBestellungen.Form\r\n frm.Filter = \"KundeID = \" & Me!KundeID\r\n frm.FilterOn = True<\/span>\r\nEnd Sub<\/span><\/pre>\n![\"Fehlermeldung](\"..\/fileadmin\/_temp_\/2017_02\/pic_1078_005.png\")
<\/p>\n Forms!frmVerknuepfteTabellen! sfmBestellungen.Form.Name\r\n sfmBestellungen<\/pre>\n
Verfeinerung des Codes<\/h2>\n
Dim <\/span>WithEvents frm_sfmBestellungen As <\/span>Form\r\nDim <\/span>WithEvents frm_sfmKunden As <\/span>Form\r\nDim <\/span>WithEvents frm_sfmBestelldetails As <\/span>Form\r\nDim <\/span>frm_sfmArtikel As <\/span>Form\r\nPrivate Sub <\/span>Form_Load()\r\n Set<\/span> frm_sfmKunden = Me!sfmKunden.Form\r\n frm_sfmKunden.OnCurrent = \"[Event Procedure]\"\r\n Set<\/span> frm_sfmBestellungen = Me!sfmBestellungen.Form\r\n frm_sfmBestellungen.OnCurrent = \"[Event Procedure]\"\r\n Set<\/span> frm_sfmBestelldetails = Me!sfmBestelldetails.Form\r\n frm_sfmBestelldetails.OnCurrent = \"[Event Procedure]\"\r\n Set<\/span> frm_sfmArtikel = Me!sfmArtikel.Form\r\nEnd Sub<\/span>\r\nPrivate Sub <\/span>frm_sfmKunden_Current()\r\n With<\/span> frm_sfmBestellungen\r\n .Filter = \"KundeID = \" & frm_sfmKunden.KundeID\r\n .FilterOn = True<\/span>\r\n End With<\/span>\r\nEnd Sub<\/span>\r\nPrivate Sub <\/span>frm_sfmBestellungen_Current()\r\n With<\/span> frm_sfmBestelldetails\r\n .Filter = \"BestellungID = \" & frm_sfmBestellungen.BestellungID\r\n .FilterOn = True<\/span>\r\n End With<\/span>\r\nEnd Sub<\/span>\r\nPrivate Sub <\/span>frm_sfmBestelldetails_Current()\r\n With<\/span> frm_sfmArtikel\r\n .Filter = \"ArtikelID = \" & frm_sfmBestelldetails.ArtikelID\r\n .FilterOn = True<\/span>\r\n End With<\/span>\r\nEnd Sub<\/span><\/pre>\nDim <\/span>WithEvents frm_sfmKunden As <\/span>Form<\/pre>\nPrivate Sub <\/span>Form_Load()\r\n Set<\/span> frm_sfmKunden = Me!sfmKunden.Form\r\n frm_sfmKunden.OnCurrent = \"[Event Procedure]\"\r\nEnd Sub<\/span><\/pre>\nPrivate Sub <\/span>frm_sfmKunden_Current()\r\n With<\/span> frm_sfmBestellungen\r\n .Filter = \"KundeID = \" & frm_sfmKunden.KundeID\r\n .FilterOn = True<\/span>\r\n End With<\/span>\r\nEnd Sub<\/span><\/pre>\nVerknüpfung aller Unterformulare<\/h2>\n
Benennung der Form-Variablen<\/h2>\n
Test des Formulars<\/h2>\n
![\"Gefilterte](\"..\/fileadmin\/_temp_\/2017_02\/pic_1078_006.png\")
<\/p>\nFlexible Gestaltung<\/h2>\n
Flexibles Unterformular<\/h2>\n
![\"Flexibles](\"..\/fileadmin\/_temp_\/2017_02\/pic_1078_008.png\")
<\/p>\nKonfigurationstabelle<\/h2>\n
![\"Tabelle](\"..\/fileadmin\/_temp_\/2017_02\/pic_1078_010.png\")
<\/p>\nDynamisches Hauptformular erstellen<\/h2>\n
![\"Entwurf](\"..\/fileadmin\/_temp_\/2017_02\/pic_1078_009.png\")
<\/p>\n![\"Datensatzherkunft](\"..\/fileadmin\/_temp_\/2017_02\/pic_1078_011.png\")
<\/p>\nPrivate Sub <\/span>cboTabellen1_AfterUpdate()\r\n Me!cboPrimaerschluessel1.RowSource = _\r\n Nz(Me!cboTabellen1)\r\n Me!cboPrimaerschluessel1 = Null\r\n Me!cboPrimaerschluessel1.SetFocus\r\n Me!cboPrimaerschluessel1.Dropdown\r\n Me!sfmTabelle1.Form.RecordSource = _\r\n Nz(Me!cboTabellen1)\r\n UnterformularEinstellen Me!sfmTabelle1.Form\r\nEnd Sub<\/span><\/pre>\nPrivate Sub <\/span>cboTabellen2_AfterUpdate()\r\n Me!cboPrimaerschluessel2.RowSource = _\r\n Nz(Me!cboTabellen2)\r\n Me!cboPrimaerschluessel2 = Null\r\n Me!cboPrimaerschluessel2.SetFocus\r\n Me!cboPrimaerschluessel2.Dropdown\r\n Me!cboFremdschluessel2.RowSource = Nz(Me!cboTabellen2)\r\n Me!cboFremdschluessel2 = Null\r\n Me!sfmTabelle2.Form.RecordSource = Nz(Me!cboTabellen2)\r\n UnterformularEinstellen Me!sfmTabelle2.Form\r\nEnd Sub<\/span><\/pre>\nEinstellen der Unterformulare<\/h2>\n
Private Sub <\/span>UnterformularEinstellen(sfm As <\/span>Form)\r\n Dim <\/span>ctl As <\/span>Control\r\n Dim <\/span>rst As <\/span>DAO.Recordset\r\n Dim <\/span>fld As <\/span>DAO.Field\r\n Dim <\/span>i As Integer<\/span>\r\n Dim <\/span>j As Integer<\/span>\r\n Set<\/span> rst = sfm.Recordset\r\n If <\/span>Not<\/span> rst Is Nothing Then<\/span>\r\n For Each fld In rst.Fields\r\n If <\/span>i = 10 Then<\/span> Exit For<\/span>\r\n i = i + 1\r\n sfm.Controls(\"txt\" & Format(i, \"00\")).ColumnHidden = False<\/span>\r\n sfm.Controls(\"txt\" & Format(i, \"00\")).ControlSource = fld.Name\r\n sfm.Controls(\"lbl\" & Format(i, \"00\")).Caption = fld.Name\r\n Debug.Print<\/span> fld.Name\r\n Next<\/span> fld\r\n End If<\/span>\r\n If <\/span>i < 10 Then<\/span>\r\n If <\/span>i = 0 Then<\/span> i = 1\r\n For j = i To 10\r\n sfm.Controls(\"txt\" & Format(j, \"00\")).ColumnHidden = True<\/span>\r\n sfm.Controls(\"txt\" & Format(j, \"00\")).ControlSource = \"\"\r\n sfm.Controls(\"lbl\" & Format(j, \"00\")).Caption = \"\"\r\n Next<\/span> j\r\n End If<\/span>\r\nEnd Sub<\/span><\/pre>\nBeim Laden des Hauptformulars<\/h2>\n
Private Sub <\/span>Form_Load()\r\n Dim <\/span>strBezeichnung As String<\/span>\r\n Dim <\/span>db As <\/span>DAO.Database\r\n Dim <\/span>lngKonfigurationID As Long<\/span>\r\n If <\/span>IsNull(Me!Bezeichnung) Then<\/span>\r\n strBezeichnung = InputBox(\"Bezeichnung eingeben:\", \"Neue Konfiguration\")\r\n If <\/span>Len<\/span>(strBezeichnung) > 0 Then<\/span>\r\n Set<\/span> db = CurrentDb\r\n db.Execute \"INSERT INTO tblKonfigurationen(Bezeichnung) VALUES(''\" & strBezeichnung & \"'')\", dbFailOnError\r\n lngKonfigurationID = db.OpenRecordset(\"SELECT @@IDENTITY\").Fields(0)\r\n Me.Requery\r\n Me.Recordset.FindFirst \"KonfigurationID = \" & lngKonfigurationID\r\n Else<\/span>\r\n DoCmd.Close acForm, Me.Name\r\n End If<\/span>\r\n End If<\/span>\r\n UnterformulareAktualisieren\r\n Set<\/span> sfm1 = Me!sfmTabelle1.Form\r\n sfm1.OnCurrent = \"[Event Procedure]\"\r\n Set<\/span> sfm2 = Me!sfmTabelle2.Form\r\n sfm2.OnCurrent = \"[Event Procedure]\"\r\n Set<\/span> sfm3 = Me!sfmTabelle3.Form\r\n sfm3.OnCurrent = \"[Event Procedure]\"\r\n Set<\/span> sfm4 = Me!sfmTabelle4.Form\r\n sfm4.OnCurrent = \"[Event Procedure]\"\r\nEnd Sub<\/span><\/pre>\nPrivate <\/span>WithEvents sfm1 As <\/span>Form\r\nPrivate <\/span>WithEvents sfm2 As <\/span>Form\r\nPrivate <\/span>WithEvents sfm3 As <\/span>Form\r\nPrivate <\/span>WithEvents sfm4 As <\/span>Form<\/pre>\nEreignis Beim Anzeigen des Hauptformulars<\/h2>\n
Private Sub <\/span>Form_Current()\r\n Me!cboKonfiguration = Me!KonfigurationID\r\n UnterformulareAktualisieren\r\nEnd Sub<\/span><\/pre>\nPrivate Sub <\/span>UnterformulareAktualisieren()\r\n Me!cboFremdschluessel4.RowSource = Nz(Me!cboTabellen4)\r\n Me!sfmTabelle4.Form.RecordSource = Nz(Me!cboTabellen4)\r\n UnterformularEinstellen Me!sfmTabelle4.Form\r\n \r\n Me!cboPrimaerschluessel3.RowSource = Nz(Me!cboTabellen3)\r\n Me!cboFremdschluessel3.RowSource = Nz(Me!cboTabellen3)\r\n Me!sfmTabelle3.Form.RecordSource = Nz(Me!cboTabellen3)\r\n UnterformularEinstellen Me!sfmTabelle3.Form\r\n \r\n Me!cboPrimaerschluessel2.RowSource = Nz(Me!cboTabellen2)\r\n Me!cboFremdschluessel2.RowSource = Nz(Me!cboTabellen2)\r\n Me!sfmTabelle2.Form.RecordSource = Nz(Me!cboTabellen2)\r\n UnterformularEinstellen Me!sfmTabelle2.Form\r\n \r\n Me!cboPrimaerschluessel1.RowSource = Nz(Me!cboTabellen1)\r\n Me!sfmTabelle1.Form.RecordSource = Nz(Me!cboTabellen1)\r\n UnterformularEinstellen Me!sfmTabelle1.Form\r\nEnd Sub<\/span><\/pre>\nUnterformulare aktualisieren<\/h2>\n
Ereignis Beim Anzeigen der Unterformulare<\/h2>\n
Private Sub <\/span>sfm1_Current()\r\n If <\/span>Len<\/span>(Me!cboFremdschluessel2) * Len<\/span>(Me!cboPrimaerschluessel1) > 0 Then<\/span>\r\n sfm2.Filter = Me!cboFremdschluessel2 & \" = \" & sfm1.Controls(Nz(Me!cboPrimaerschluessel1))\r\n sfm2.FilterOn = True<\/span>\r\n Else<\/span>\r\n sfm2.Filter = \"\"\r\n End If<\/span>\r\nEnd Sub<\/span><\/pre>\nKundeID = 123<\/pre>\n
Auswählen einer anderen Konfiguration<\/h2>\n
Private Sub <\/span>cboKonfiguration_AfterUpdate()\r\n Me.Recordset.FindFirst \"KonfigurationID = \" _\r\n & Me!cboKonfiguration\r\nEnd Sub<\/span><\/pre>\nHinzufügen einer neuen Konfiguration<\/h2>\n
Private Sub <\/span>cmdNeu_Click()\r\n Dim <\/span>strBezeichnung As String<\/span>\r\n Dim <\/span>db As <\/span>DAO.Database\r\n Dim <\/span>lngKonfigurationID As Long<\/span>\r\n strBezeichnung = InputBox(\"Bezeichnung eingeben:\", \"Neue Konfiguration\")\r\n If <\/span>Len<\/span>(strBezeichnung) > 0 Then<\/span>\r\n Set<\/span> db = CurrentDb\r\n db.Execute \"INSERT INTO tblKonfigurationen(Bezeichnung) VALUES(''\" & strBezeichnung & \"'')\", dbFailOnError\r\n lngKonfigurationID = db.OpenRecordset(\"SELECT @@IDENTITY\").Fields(0)\r\n Me.Requery\r\n Me.Recordset.FindFirst \"KonfigurationID = \" & lngKonfigurationID\r\n End If<\/span>\r\nEnd Sub<\/span><\/pre>\n