<\/p>\n
Im Beitrag „Mehrere Datensätze pro Spalte in Formularen“ haben wir gezeigt, wie Sie mehrere Unterformulare in einem Formular mit jeweils einem Datensatz füllen, sodass der Eindruck entsteht, die Datensätze seien innerhalb des Formulars in Spalten und Zeilen arrangiert. Im vorliegenden Beitrag zeigen wir ein Beispiel für den praktischen Einsatz dieser Lösung. Dabei wollen wir die Daten einer Kundendatenbank wie in der Kontakte-Ansicht von Outlook als Visitenkarten darstellen – mit der zusätzlichen Option, einen Kontakt direkt von der übersicht aus löschen zu können.<\/b><\/p>\n
Im Beitrag Mehrere Datensätze pro Spalte in Formularen <\/b>(www.access-im-unternehmen.de\/1010<\/b>) haben wir ja einigen Code in den Klassenmodulen des Haupt- und Unterformulars untergebracht, der teilweise auch noch an die verwendete Datenherkunft (die Tabelle tblKunden<\/b>) angepasst war.<\/p>\n
Wenn Sie die dort vorgestellten Techniken in weiteren Formularen nutzen wollen, sollten Sie nicht immer den kompletten Code übertragen und anpassen müssen.<\/p>\n
Deshalb haben wir den Code in zwei Klassenmodule ausgelagert. Diese müssen Sie nur noch für die gewünschte Konfiguration konfigurieren und initialisieren, was mit einem einzigen Befehl möglich ist. Damit müssen Sie sich weniger mit der Programmierung auseinandersetzen und können sich etwas mehr auf das Design konzentrieren.<\/p>\n
Um eine schöne Kontaktübersicht wie in Outlook zu erstellen, legen Sie dazu zunächst ein Hauptformular an, dem Sie die Steuerelemente zum Blättern in den Kontakten hinzufügen. Diese benennen Sie beispielsweise cmdNachOben<\/b>, cmdNachUnten <\/b>und cmdNeu<\/b>. Außerdem benötigen Sie noch ein Bezeichnungsfeld zur Anzeige der aktuellen Position, das in diesem Fall lblEintraege <\/b>heißen soll.<\/p>\n
Das Hauptformular sieht demnach zunächst wie in Bild 1 aus und erhält den Namen frmKontakteVerwalten<\/b>. Um die Optik kümmern wir uns später, wir wollen zunächst die Funktionalität sicherstellen.<\/p>\n
![\"Hauptformular](\"..\/fileadmin\/_temp_\/2016_01\/pic_1019_001.png\")
<\/p>\n
Bild 1: Hauptformular für die Anzeige der Kontakte<\/span><\/b><\/p>\n Bevor wir uns um das Unterformular kümmern, stellen Sie noch die Eigenschaften Navigationsschaltflächen<\/b>, Datensatzmarkierer<\/b>, Bildlaufleisten <\/b>und Trennlinien <\/b>auf den Wert Nein <\/b>ein. Diese Elemente benötigen wir nicht, da das Hauptformular ja komplett ungebunden ist.<\/p>\n Im zweiten Schritt legen Sie ein Unterformular namens sfm-Kon-takteVerwalten <\/b>an, dem Sie – nur zum Hinzufügen der entsprechenden Steuerelemente – die zu verwendende Datenherkunft zuweisen. In diesem Fall verwenden wir eine Tabelle namens tblKunden<\/b>, die im Entwurf wie in Bild 2 aussieht.<\/p>\n Bild 2: Entwurf der Tabelle mit den anzuzeigenden Kontaktdaten<\/span><\/b><\/p>\n Fügen Sie dann die Felder der Tabelle hinzu und ordnen Sie diese wie in Bild 3 an. Da nur ein Datensatz je Unterformular angezeigt werden soll, benötigen wir die Elemente zum Navigieren innerhalb der Datensätze des Unterformulars nicht. Stellen Sie daher die Eigenschaften Navigationsschaltflächen<\/b>, Datensatzmarkierer<\/b>, Bildlaufleisten <\/b>und Trennlinien <\/b>auf den Wert Nein <\/b>ein. Außerdem legen Sie den Wert der Eigenschaft Zyklus <\/b>auf Aktueller Datensatz <\/b>fest, damit der Benutzer den Datensatz beim Navigieren mit der Tab<\/b>-Taste nicht wechseln kann.<\/p>\n Bild 3: Hinzufügen der Felder zum Unterformular sfmKontakteVerwalten<\/span><\/b><\/p>\n Außerdem fügen Sie noch eine Schaltfläche namens cmdLoeschen <\/b>hinzu, die Sie, genau wie die Schaltflächen im Hauptformular, nicht mit einer Ereignisprozedur zu versehen brauchen. Das Unterformular sieht dann in der Formularansicht wie in Bild 4 aus.<\/p>\n Bild 4: Das Unterformular in der Formularansicht<\/span><\/b><\/p>\n Wichtig ist hier, dass Sie nur wenig Platz zwischen den Steuerelementen und dem Seitenrand lassen. Nur wenn die Rahmenlinien der enthaltenen Steuerelemente angezeigt werden sollen, lassen Sie einen Abstand von 1 <\/b>zwischen den Steuerelementen und den Seitenrändern des Detailbereichs des Unterformulars. Abstände fügen wir später durch die Positionierung der Unterformulare im Hauptformular hinzu.<\/p>\n Nun müssen Sie nur noch Unterformular-Steuerelemente in der gewünschten Anzahl zum Hauptformular hinzufügen. Die Betonung liegt auf Unterformular-Steuerelemente<\/b>, denn wir wollen diese Steuerelemente erst zur Laufzeit mit dem Verweis auf das Unterformular selbst füllen. Um die Größe optimal einzustellen, sollten Sie jedoch fürs Erste einfach das komplette Unterformular zum Hauptformular hinzufügen. Dies erledigen Sie am einfachsten, indem Sie das Hauptformular in der Entwurfsansicht öffnen und das Unterformular aus dem Navigationsbereich an die gewünschte Stelle im Entwurf ziehen.<\/p>\n Hier entfernen Sie zunächst das Bezeichnungsfeld des Unterformular-Steuerelements. Danach wechseln Sie in die Formularansicht des Hauptformulars, um zu prüfen, ob alle Elemente des Unterformulars wie gewünscht angezeigt werden. Die Ansicht aus Bild 5 macht uns darauf aufmerksam, dass die ständige Wiederholung der Bezeichnungsfelder für jeden Datensatz wohl wenig Sinn macht und eine Menge Platz benötigt – also gehen wir nochmals in den Entwurf des Unterformulars und entfernen die Bezeichnungsfelder.<\/p>\n Bild 5: Erster Test des Unterformulars im Hauptformular<\/span><\/b><\/p>\n Nachdem dies erledigt ist, ziehen wir das Unterformular erneut in das Hauptformular und entfernen wieder das Bezeichnungsfeld des Unterformular-Steuerelements. Nun passt alles!<\/p>\n Sie können nun das Unterformular mit Strg + C <\/b>kopieren und Strg + V <\/b>so oft in das Formular einfügen, wie Sie es wünschen. Ordnen Sie die Unterformulare dabei so wie in Bild 6 an und lassen Sie etwas Platz dazwischen.<\/p>\n Bild 6: Fertig angeordnete Unterformulare<\/span><\/b><\/p>\n Stellen Sie die Eigenschaft Rahmenart <\/b>des Unterformular-Steuerelements nach Wunsch auf Transparent <\/b>ein, um die Rahmen um jeden Kontakt zu entfernen.<\/p>\n Wenn Sie nun in die Formularansicht wechseln, erhalten Sie die Ansicht aus Bild 7. Alle Unterformulare zeigen den gleichen Datensatz an – und zwar den ersten, den die Datenherkunft liefert.<\/p>\n Bild 7: Alle Unterformulare zeigen den gleichen Datensatz an.<\/span><\/b><\/p>\n Das ist auch logisch, denn wir haben dem Formular ja noch keinerlei Logik hinzugefügt. Bevor wir dies tun, ist auch noch ein weiterer Schritt nötig: Damit die Programmlogik die Unterformulare mit den gewünschten Daten füllen kann, müssen diese noch entsprechende Namen erhalten.<\/p>\n Daher benennen Sie diese von links nach rechts und dann von oben nach unten mit Namen nach dem Schema sfm-XX<\/b>, wobei XX <\/b>bei 00 <\/b>beginnt und dann jeweils um eins erhöht wird. Bild 8 zeigt die Namen der Unterformular-Steuerelemente für eine Konfiguration mit drei mal drei Unterformularen.<\/p>\n Bild 8: Namen der Unterformular-Steuerelemente<\/span><\/b><\/p>\n Damit kommen wir zum Einsatz der beiden Klassen clsDatenNebeneinander <\/b>und clsDatenNebeneinanderUnterformular<\/b>. Fügen Sie dem Formular frmKontakteVerwalten <\/b>eine Prozedur hinzu, die durch das Ereignis Beim Laden <\/b>ausgelöst wird. Diese ergänzen Sie um eine der Anweisungen aus Listing 1.<\/p>\n Listing 1: Initialisieren der Unterformulare und der Funktionen zum Blättern, Anlegen und Löschen<\/span><\/b><\/p>\n Hier deklarieren wir zunächst eine Objektvariable des Typs clsDatenNebeneinander <\/b>im Kopf des Klassenmoduls. Dies bewirkt, dass das Objekt auch nach dem Beenden der Form_Load<\/b>-Prozedur, welche die Variable füllt, noch vorhanden ist. Die Form_Load<\/b>-Prozedur erstellt ein neues Objekt auf Basis der Klasse clsDatenNebeneinander <\/b>und speichert den Verweis darauf in der Variablen objDatenNebeneinander<\/b>. Nun fehlt nur noch ein Schritt, nämlich das übergeben der Daten für die Funktion dieser Klasse. Dies erfolgt mit der Methode Initialisieren<\/b>, welche die folgenden Parameter erwartet:<\/p>\n <\/p>\n öffnen Sie das Formular nun in der Formularansicht, erhalten Sie die gewünschten Daten wie in Bild 9. Das Vor- und Zurückblättern gelingt ebenso wie das Anlegen neuer und das Löschen vorhandener Datensätze.<\/p>\n Bild 9: Formular mit gefüllten Unterformularen<\/span><\/b><\/p>\n Es stellt sich nun zum Beispiel noch die Frage, warum der Aufruf der Methode Initialisieren <\/b>keine Angabe der Anzahl der zu füllenden Unterformulare enthält.<\/p>\n Der Grund ist einfach: Wenn Sie die Unterformular-Steuer-elemente nach den Vorgaben benennen, also mit sfm00<\/b>, sfm01 <\/b>und so weiter, durchläuft die Klasse diese einfach und füllt alle vorhandenen Unterformulare.<\/p>\n Erst, wenn es das nächste Unterformular-Steuerelement in der Reihenfolge nicht mehr findet, geht es davon aus, dass es alle Unterformulare gefüllt hat.<\/p>\n Gegenüber der Basisversion, die wir im Beitrag Mehrere Datensätze pro Spalte in Formularen <\/b>(www.access-im-unternehmen.de\/1010<\/b>) vorgestellt haben, mussten wir natürlich einige Elemente umbauen – immerhin sollte ja die komplette Funktionalität, die dort in Haupt- und Unterformular steckte, nun in zwei Klassen ausgelagert werden, die nur noch per Initialisieren<\/b>-Methode aufgerufen werden sollen.<\/p>\n Diese Methode ist dann auch das steuerende Element, wenn es um die Vorbereitung des Formulars geht (s. Listing 2).<\/p>\n Listing 2: Die Methode zum Initialisieren von Haupt- und Unterformularen samt Steuerelementen<\/span><\/b><\/p>\n Die erwarteten Parameter haben wir ja weiter oben bereits besprochen. Die Methode füllt zunächst einige Membervariablen mit Verweisen auf die jeweiligen Elemente. Diese werden im Klassenmodul clsDatenNebeneinander <\/b>wie folgt deklariert und mit dem führenden Buchstaben m <\/b>und einem Unterstrich charakterisiert:<\/p>\n Einige Variablen sind mit dem Schlüsselwort WithEvents <\/b>deklariert, was bedeutet, dass wir für diese in der gleichen Klasse auch noch Ereignisprozeduren implementieren wollen – etwa, um das Ereignis, das beim Klicken auf die Schaltfläche cmdNachUnten <\/b>ausgelöst wird, innerhalb der Klasse clsDatenNebeneinander <\/b>unterbringen zu können und nicht im Klassenmodul des Formulars.<\/p>\n Es fehlt aber noch eine Variable für die Schaltfläche cmdLoeschen<\/b> Das ist richtig, allerdings wird diese ja für jedes Unterformular benötigt – und wir legen später für jedes Unterformular eine Instanz der Klasse clsDatenNebeneinanderUnterformular <\/b>an, welche sich dann um die Eigenschaften der Unterformulare kümmert.<\/p>\n Neben diesen Membervariablen benötigen wir noch einige weitere lokale Variablen:<\/p>\n colSubforms <\/b>ist dabei wichtig, denn diese Collection nimmt später die Instanzen der Klasse clsDatenNebeneinanderUnterformular <\/b>auf.<\/p>\n Die Methode Initialisieren <\/b>weist den Member-Variablen nun zunächst die mit den Parametern übergebenen Objektverweise und Werte zu. Bei den Objekten, die Ereignisse auslösen, trägt sie gleich den Wert [Event Procedure] <\/b>für die jeweilige Ereigniseigenschaft ein. Bei der Schaltfläche cmdNachOben<\/b>, die in der Variablen m_NachOben <\/b>gespeichert wird, erhält so beispielsweise die Eigenschaft OnClick <\/b>diesen Wert. Danach testet die Methode, ob das Unterformular-Steuerelement sfm00 <\/b>vorhanden ist. Dazu versucht sie, bei deaktivierter Fehlerbehandlung die Variable objSubform <\/b>mit einem Verweis auf dieses Unterformular-Steuerelement zu füllen. Falls ja, steigt es in eine Do While<\/b>-Schleife ein, die erst beendet wird, wenn kein neues Unterformular entsprechend der vorgegebenen Namenskonvention mehr gefunden wird (sfm00<\/b>, sfm01 <\/b>und so weiter). Innerhalb der Schleife erhöht die Methode den Wert der Zählervariablen i <\/b>jeweils um 1 <\/b>und weist dem Unterformular-Steuerelement das anzuzeigende Unterformular zu. Dieses ist zwischenzeitlich vom Parameter strSubform <\/b>in der Membervariablen m_Subform <\/b>gelandet. Danach stellt sie die Variable objSubform<\/b> auf Nothing <\/b>ein und versucht, das nächste Unterformular mit m_Form(„sfm“ & Format(1, „00“)) <\/b>zu referenzieren.<\/p>\n Nachdem alle Unterformular-Steuerelemente mit dem jeweiligen Unterformular gefüllt wurden, trägt die Methode den aktuellen Wert von i<\/b>, welcher der Anzahl der Unterformulare entspricht, in die Variable intUnterformulare <\/b>ein und ruft eine weitere Prozedur namens m_Form_Load <\/b>auf. Der Name dieser Prozedur ist historisch bedingt, denn wir haben diese aus der Datenbankversion des zu Beginn erwähnten Beitrags übernommen, wo diese noch als Ereignisprozedur des Hauptformulars vorlag. Hier wird m_Form_Load <\/b>allerdings nicht mehr beim Laden des Hauptformulars ausgelöst, da die Klasse ja erst im eigentlichen Form_Load<\/b>-Ereignis des Hauptformulars instanziert und initialisiert wurde.<\/p>\n Die Prozedur m_Form_Load <\/b>liest die angegebene Datenherkunft in ein Recordset ein und stellt den klasseninternen Datensatzindex intStartdatensatz <\/b>auf den Wert 1 <\/b>ein. Die Prozedur ruft dann eine weitere Routine namens UnterformulareFuellen <\/b>auf und übergibt dieser mit int-Elemente <\/b>eine Variable, die von der aufgerufenen Methode gefüllt werden soll. Das Ergebnis wird dann genutzt, um die Schaltflächen aus m_NachUnten <\/b>und m_Nach-Oben <\/b>zu aktivieren oder deaktivieren.<\/p>\n Das Füllen der Unterformulare übernimmt dann die Prozedur UnterformulareFuellen<\/b>. Diese entspricht im Wesentlichen der Methode, die wir schon im Beitrag Mehrere Datensätze pro Spalte in Formularen <\/b>erläutert haben – mit dem Unterschied, dass Sie noch die Routine UnterformulareInitialisieren <\/b>aufruft (s. Listing 3).<\/p>\n Listing 3: Diese Prozedur initialisiert für jedes Unterformular ein Element auf Basis der Klasse clsDatenNebeneinanderUnterformular<\/span><\/b><\/p>\n Diese instanziert die Collection<\/b>-Variable colSubforms<\/b> und durchläuft dann eine For…Next<\/b>-Schleife über die gesamte Anzahl der Unterformulare aus der Variablen intUnterformulare<\/b>. Innerhalb dieser Schleife trägt sie einen Verweis auf das jeweilige Unterformular in die Variable objSubform <\/b>ein. Dann erstellt sie eine neue Instanz der Klasse clsDatenNebeneinanderUnterformular <\/b>und weist dieser vier Eigenschaften zu:<\/p>\n Danach trägt sie mit der Add<\/b>-Methode den Verweis auf das neu erstellte und konfigurierte Objekt in die Collection namens colSubforms <\/b>ein.<\/p>\n Diese Klasse hält die Ereignisse bereits, die durch jedes der angezeigten Unterformulare ausgelöst werden sollen – also diejenigen, die zuvor im Beispiel des vorherigen Beitrags im Klassenmodul des Formulars sfmKundenNebeneinander <\/b>enthalten waren (s. Listing 4). Damit Sie die dazu notwendigen Codezeilen nicht bei jeder neuen Implementierung in das Klassenmodul des Unterformulars eintragen müssen, haben wir diese in ein weiteres Klassenmodul ausgelagert. Dieses verwendet wieder zwei Objektvariablen, die mit dem Schlüsselwort WithEvents <\/b>deklariert wurden und dementsprechend Ereignisse implementieren sollen. Dabei handelt es sich um das Unterformular-Objekt sowie die Löschen<\/b>-Schaltfläche:<\/p>\n Listing 4: Inhalt der Klasse clsDatenNebeneinanderUnterformular<\/span><\/b><\/p>\n Weitere Membervariablen nehmen die Verweise auf das übergeordnete Formular und die übergeordnete Klasse clsDatenNebeneinander <\/b>auf:<\/p>\nUnterformular erstellen<\/h2>\n
![\"Entwurf](\"..\/fileadmin\/_temp_\/2016_01\/pic_1019_002.png\")
<\/p>\n![\"Hinzufügen](\"..\/fileadmin\/_temp_\/2016_01\/pic_1019_003.png\")
<\/p>\n![\"Das](\"..\/fileadmin\/_temp_\/2016_01\/pic_1019_004.png\")
<\/p>\nUnterformulare-Steuerelemente einfügen<\/h2>\n
![\"Erster](\"..\/fileadmin\/_temp_\/2016_01\/pic_1019_005.png\")
<\/p>\n![\"Fertig](\"..\/fileadmin\/_temp_\/2016_01\/pic_1019_006.png\")
<\/p>\n![\"Alle](\"..\/fileadmin\/_temp_\/2016_01\/pic_1019_007.png\")
<\/p>\n![\"Namen](\"..\/fileadmin\/_temp_\/2016_01\/pic_1019_008.png\")
<\/p>\nUnterformulare füllen<\/h2>\n
Dim <\/span>objDatenNebeneinander As <\/span>clsDatenNebeneinander\r\nPrivate Sub <\/span>Form_Load()\r\n Set<\/span> objDatenNebeneinander = New<\/span> clsDatenNebeneinander\r\n With<\/span> objDatenNebeneinander\r\n .Initialisieren Me, Me!cmdNachUnten, Me!cmdNachOben, Me!cmdNeu, Me!lblEintraege, \"sfmKontakteVerwalten\", _\r\n \"tblKunden\", \"KundeID\", \"cmdLoeschen\"\r\n End With<\/span>\r\nEnd Sub<\/span><\/pre>\n\n
![\"Formular](\"..\/fileadmin\/_temp_\/2016_01\/pic_1019_009.png\")
<\/p>\nTechnische Hintergründe<\/h2>\n
Formulare mit Leben füllen<\/h2>\n
Public Sub <\/span>Initialisieren(frm As <\/span>Form, cmdNachUnten As <\/span>CommandButton, cmdNachOben As <\/span>CommandButton, _\r\n cmdNeu As <\/span>CommandButton, lblEintraege As <\/span>Label, strSubform As String<\/span>, strRecordsource As String<\/span>, _\r\n strPrimaerschluessel As String<\/span>, strLoeschen As String<\/span>)\r\n Dim <\/span>i As Integer<\/span>\r\n Set<\/span> m_Form = frm\r\n Set<\/span> m_NachOben = cmdNachOben\r\n With<\/span> m_NachOben\r\n .OnClick = \"[Event Procedure]\"\r\n End With<\/span>\r\n Set<\/span> m_NachUnten = cmdNachUnten\r\n With<\/span> m_NachUnten\r\n .OnClick = \"[Event Procedure]\"\r\n End With<\/span>\r\n Set<\/span> m_Neu = cmdNeu\r\n With<\/span> m_Neu\r\n .OnClick = \"[Event Procedure]\"\r\n End With<\/span>\r\n Set<\/span> m_Eintraege = lblEintraege\r\n m_Recordsource = strRecordsource\r\n m_Primaerschluesselfeld = strPrimaerschluessel\r\n m_Subform = strSubform\r\n m_strLoeschen = strLoeschen\r\n On Error Resume Next<\/span>\r\n Set<\/span> objSubform = m_Form(\"sfm00\")\r\n On Error GoTo<\/span> 0\r\n If <\/span>objSubform.Form.HasModule = False<\/span> Then<\/span>\r\n MsgBox<\/span> \"Die Eigenschaft ''Enthält Modul'' muss für das Formular ''\" & m_Subform & \"'' auf ''Ja'' eingestellt werden.\"\r\n Exit Sub<\/span>\r\n End If<\/span>\r\n Do While<\/span> Not<\/span> objSubform Is Nothing\r\n i = i + 1\r\n objSubform.SourceObject = m_Subform\r\n Set<\/span> objSubform = Nothing\r\n On Error Resume Next<\/span>\r\n Set<\/span> objSubform = m_Form(\"sfm\" & Format(i, \"00\"))\r\n On Error GoTo<\/span> 0\r\n Loop<\/span>\r\n intUnterformulare = i\r\n m_Form_Load\r\nEnd Sub<\/span><\/pre>\nDim <\/span>WithEvents m_Form As <\/span>Form\r\nDim <\/span>WithEvents m_NachOben As <\/span>CommandButton\r\nDim <\/span>WithEvents m_NachUnten As <\/span>CommandButton\r\nDim <\/span>WithEvents m_Neu As <\/span>CommandButton\r\nDim <\/span>m_Recordsource As String<\/span>\r\nDim <\/span>m_Subform As String<\/span>\r\nDim <\/span>m_Primaerschluesselfeld As String<\/span>\r\nDim <\/span>m_Eintraege As <\/span>Label\r\nDim <\/span>m_strLoeschen As String<\/span><\/pre>\nDim <\/span>db As <\/span>DAO.Database\r\nDim <\/span>rst As <\/span>DAO.Recordset\r\nDim <\/span>intStartdatensatz As Integer<\/span>\r\nDim <\/span>objSubform As <\/span>Subform\r\nDim <\/span>colSubforms As <\/span>Collection\r\nDim <\/span>intUnterformulare As Integer<\/span><\/pre>\nUnterformulare füllen<\/h2>\n
Private Sub <\/span>UnterformulareInitialisieren()\r\n Dim <\/span>i As Integer<\/span>\r\n Dim <\/span>objDatenNebeneinanderUnterformular As <\/span>clsDatenNebeneinanderUnterformular\r\n Set<\/span> colSubforms = New<\/span> Collection\r\n For i = 0 To intUnterformulare - 1\r\n Set<\/span> objSubform = m_Form(\"sfm\" & Format(i, \"00\"))\r\n Set<\/span> objDatenNebeneinanderUnterformular = New<\/span> clsDatenNebeneinanderUnterformular\r\n With<\/span> objDatenNebeneinanderUnterformular\r\n Set<\/span> .Form = m_Form\r\n Set<\/span> .Subform = objSubform.Form\r\n .Loeschen = m_strLoeschen\r\n Set<\/span> .Parent = Me\r\n End With<\/span>\r\n colSubforms.Add objDatenNebeneinanderUnterformular\r\n Next<\/span> i\r\nEnd Sub<\/span><\/pre>\n\n
Die Klasse clsDatenNebeneinanderUnterformular<\/h2>\n
Private <\/span>WithEvents m_Subform As <\/span>Form\r\nPrivate <\/span>m_Form As <\/span>Form\r\nPrivate <\/span>WithEvents cmdLoeschen As <\/span>CommandButton\r\nPrivate <\/span>m_Parent As <\/span>clsDatenNebeneinander\r\nPublic Property Set<\/span> <\/span>Subform(frm As <\/span>Form)\r\n Set<\/span> m_Subform = frm\r\n With<\/span> m_Subform\r\n .AfterDelConfirm = \"[Event Procedure]\"\r\n .AfterInsert = \"[Event Procedure]\"\r\n .OnCurrent = \"[Event Procedure]\"\r\n End With<\/span>\r\nEnd Property<\/span>\r\nPublic Property Set<\/span> <\/span>Form(frm As <\/span>Form)\r\n Set<\/span> m_Form = frm\r\nEnd Property<\/span>\r\nPublic Property Let <\/span>Loeschen(strLoeschen As String<\/span>)\r\n Set<\/span> cmdLoeschen = m_Subform.Controls(strLoeschen)\r\n With<\/span> cmdLoeschen\r\n .OnClick = \"[Event Procedure]\"\r\n End With<\/span>\r\nEnd Property<\/span>\r\nPublic Property Set<\/span> <\/span>Parent(obj As <\/span>clsDatenNebeneinander)\r\n Set<\/span> m_Parent = obj\r\nEnd Property<\/span>\r\nPrivate Sub <\/span>cmdLoeschen_Click()\r\n m_Parent.DatensatzLoeschen\r\nEnd Sub<\/span>\r\nPrivate Sub <\/span>m_Subform_AfterDelConfirm(Status As Integer<\/span>)\r\n m_Parent.DatensatzGeloescht\r\nEnd Sub<\/span>\r\nPrivate Sub <\/span>m_Subform_AfterInsert()\r\n m_Parent.DatensatzHinzugefuegt\r\nEnd Sub<\/span>\r\nPrivate Sub <\/span>m_Subform_Current()\r\n cmdLoeschen.Enabled = Not<\/span> m_Subform.NewRecord\r\nEnd Sub<\/span><\/pre>\nPrivate <\/span>WithEvents m_Subform As <\/span>Form\r\nPrivate <\/span>WithEvents cmdLoeschen As <\/span>CommandButton<\/pre>\nPrivate <\/span>m_Form