<\/p>\n
üblicherweise landen in einem Access-Formular entweder die Details eines Datensatzes oder mehrere Datensätze. Erstere können über das Formular verteilt werden, Letztere erscheinen untereinander in der Datenblattansicht oder der Endlosansicht. Mit einigen Unterformular-Steuerelementen lassen sich jedoch auch mehrere Datensätze nebeneinander anzeigen. Dieser Beitrag zeigt die Grundlagen zur Anzeige mehrerer Datensätze in einer Matrix von Unterformularen.<\/b><\/p>\n
Grundlage für die Anzeige mehrerer Datensätze nebeneinander ist, dass Sie für jeden Datensatz ein Unterformular anlegen und diese dann nebeneinander anordnen. Die Datenherkünfte der Unterformulare müssen Sie dann noch so gestalten, dass diese jeweils den gewünschten Datensatz anzeigen. Wenn Sie also beispielsweise drei Kundendatensätze nebeneinander anzeigen wollen, müssten Sie dem ersten Unterformular den ersten Datensatz der Datenherkunft , dem zweiten den zweiten Datensatz und so weiter zuweisen.<\/p>\n
Das Blättern in solchen Daten ist natürlich nicht mehr über die Bildlaufleiste möglich – dazu müssten Sie sich mit eigenen Steuerelementen wie etwa einer Nach oben<\/b>– oder Nach unten<\/b>-Schaltfläche behelfen. Natürlich könnte man auch die herkömmliche Bildlaufleiste nutzen, aber dann müsste das Formular so viele Unterformulare enthalten, dass alle Datensätze der Datenherkunft angezeigt werden können.<\/p>\n
Mit steigender Datensatzanzahl sinkt hier die Performance, und auch die Anzahl der Unterformularsteuerelemente ist natürlich begrenzt. Also wollen wir es lieber bei einer vordefinierten Anzahl belassen und eigene Schaltflächen zum Blättern zwischen den Datensätzen verwenden. Das Ergebnis soll in der Rohfassung wie in Bild 1 aussehen. Das Hauptformular legen Sie als einfaches Formular mit der Bezeichnung frmKundenNebeneinander <\/b>an und speichern dieses. <\/p>\n
![\"Unterformulare](\"..\/fileadmin\/_temp_\/2015_06\/pic_1010_001.png\")
<\/p>\n
Bild 1: Unterformulare in mehreren Spalten zur Anzeige von Daten<\/span><\/b><\/p>\n Im folgenden Beispiel wollen wir zwölf Unterformulare in drei Spalten und vier Zeilen anordnen. Die Unterformulare sollen die Bezeichnungen sfm01<\/b>, smf02 <\/b>und so weiter erhalten. Damit die Unterformulare korrekt positioniert und mit den richtigen Abmessungen ausgestattet werden, wollen wir diese mit einem kleinen Skript zum Hauptformular hinzufügen.<\/p>\n Dieses sieht wie in Listing 1 aus und ist in der Beispieldatenbank im Modul mdlTools <\/b>zu finden. Die Prozedur erwartet einige Parameter, welche den Namen des mit Unterformularen auszustattenden Formulars sowie die Abmessungen für die Unterformularsteuerelemente enthalten. Dabei liefern intX <\/b>und intY <\/b>zunächst die Anzahl der anzulegenden Unterformulare je Zeile und Spalte. lngBreite <\/b>und lngHoehe <\/b>enthalten die Abmessungen, lngAbstand-X <\/b>und lngAbstandY <\/b>den Abstand der Unterformulare untereinander und zum linken und oberen Rand des Formulars. Schließlich legen Sie mit strSubform<\/b>, soweit gewünscht, noch den Wert der Eigenschaft Herkunftsobjekt <\/b>(VBA: SourceObject<\/b>) fest.<\/p>\n Listing 1: Hinzufügen der Unterformulare zum Hauptformular<\/span><\/b><\/p>\n Für die Konstellation in der Beispieldatenbank haben wir den folgenden Aufruf der Prozedur zusammengestellt:<\/p>\n Damit legt diese 3 x 4 Unterformularsteuerelemente an und füllt diese gleich mit dem Unterformular sfmKundenNebeneinander<\/b>. Die Prozedur schließt zunächst das mit strForm <\/b>übergebene Formular, sofern dieses noch geöffnet ist, und öffnet es erneut, diesmal in der Entwurfsansicht. Dann speichert es einen Verweis auf das Formular in der Variablen frm<\/b>.<\/p>\n In einer For…Next<\/b>-Schleife über alle im Formular enthaltenen Steuerelemente löscht sie dann alle bereits vorhandenen Unterformulare. Sie sollten die Routine also nicht für Formulare nutzen, die bereits für andere Zwecke vorgesehene Unterformulare enthalten, oder aber eine Prüfung einbauen, welche nur die in vorherigen Aufrufen angelegte Unterformularsteuerelemente löscht. Zum Löschen der Steuerelemente verwendet die Routine die DeleteControl<\/b>-Methode, die den Namen des Formulars und des zu löschenden Steuerelements enthält.<\/p>\n Danach durchläuft die Prozedur zwei verschachtelte For…Next<\/b>-Schleifen über die Werte von 1 <\/b>bis intY <\/b>beziehungsweise 1 <\/b>bis intX<\/b>. In der Schleife erhöht sie den Wert der Variablen i<\/b>, die zuvor auf 0 <\/b>eingestellt wurde, um 1<\/b>. i <\/b>soll die Nummer für den Steuerelementnamen (sfm01<\/b>, sfm02 <\/b>und so weiter) liefern. Nun folgt die Methode CreateControl<\/b>, welche das eigentliche Steuerelement erstellt. Sie erwartet den Namen des Zielformulars, den Typ des zu erstellenden Steuerelements, den Zielbereich (hier den Detailbereich) sowie die Koordinaten und Abmessungen.<\/p>\n Die Abmessungen entnimmt die Routine den Parametern intHoehe <\/b>und intBreite<\/b>, die Koordinaten werden für jedes Steuerelement neu berechnet. Der Abstand vom linken Formularrand stammt dabei aus der Formel lngAbstandX + (lngAbstandX + lngBreite) * (x – 1)<\/b>. Im ersten Durchlauf ist x = 0<\/b>, also ist der Abstand der mit lngAbstandX <\/b>übergebene Wert. Für die folgenden Elemente, die natürlich rechts neben dem jeweils zuvor platzierten Element landen sollen, ermittelt die Routine die Position aus dem Abstand des ersten Elements vom linken Rand plus dem Produkt der Breite eines Elements plus dem einfachen Abstand und dem Index des Steuerelements. Auf die gleiche Art berechnet die Routine den Abstand vom oberen Formularrand.<\/p>\n Die Variable ctl <\/b>speichert den Verweis auf das soeben erstellte Steuerelement. Damit weist die Routine noch den Namen für das Steuerelement zu. Wenn strSubform <\/b>den Namen des Unterformulars enthält, der im Unterformularsteuerelement angezeigt werden soll, weist die Prozedur diesen der Eigenschaft SourceObject <\/b>des Unterformularsteuerelements zu. Diesen Vorgang wiederholt die Prozedur, bis alle Zeilen und Spalten in den For…Next<\/b>-Schleifen durchlaufen wurden. Das Ergebnis sieht zu diesem Zeitpunkt etwa wie in Bild 2 aus.<\/p>\n Bild 2: Frisch angelegte Unterformulare in der Entwurfsansicht<\/span><\/b><\/p>\n Schließlich benötigen wir auch noch das Unterformular, das in den Unterformularsteuerelementen des Hauptformulars erscheinen und die verschiedenen Datensätze anzeigen soll. Die Herkunftstabelle heißt tblKunden <\/b>und liefert einige Felder, die wir wie in Bild 3 im Unterformular sfmKundenNebeneinander <\/b>anorden. Außerdem legen wir dort schon einmal eine Schaltfläche namens cmdLoeschen<\/b> an, die später das Löschen des im Unterformular angezeigten Datensatzes erlauben soll.<\/p>\n Bild 3: Das Unterformular der Beispielanwendung<\/span><\/b><\/p>\n Wenn Sie nun das Hauptformular in der Formularansicht öffnen, zeigt dieses für jedes Unterformular den gleichen Datensatz an (s. Bild 4). Kein Wunder: Das Unterformular ist ja in allen Fällen genau gleich aufgebaut und zeigt dementsprechend auch die gleichen Daten an – zumindest, bis wir gleich mit einigen Zeilen Code eingreifen.<\/p>\n Bild 4: Gleicher Datensatz in allen Unterformularen<\/span><\/b><\/p>\n Die Unterformulare füllen wir gleich beim öffnen des Hauptformulars, und zwar in der Ereignisprozedur, die durch das Ereignis Beim Laden <\/b>ausgelöst wird (s. Listing 2). Diese Prozedur verwendet bereits einige Variablen, die wir modulweit im Kopf des Klassenmoduls Form_frmKundenNebeneinander <\/b>deklarieren:<\/p>\n <\/p>\n Listing 2: Füllen der Unterformulare mit den gewünschten Datensätzen<\/span><\/b><\/p>\n Die Prozedur füllt die Variable db <\/b>mit einem Verweis auf das aktuelle Database<\/b>-Objekt. Die Recordset-Variable rst <\/b>füllt die Prozedur mit den Daten der Tabelle tblKunden<\/b>.<\/p>\n Mit der Variablen intElemente <\/b>als Parameter ruft die Prozedur damit die Routine UnterformulareFuellen <\/b>auf. Diese ist letztlich dafür verantwortlich, in den Unterformularen den richtigen Datensatz anzuzeigen. Da wir später mit dem Formular durch die Kundendatensätze blättern wollen, benötigen wir noch die aktuelle Position. Dazu tragen wir den Wert 1 <\/b>in die Variable intStartdatensatz <\/b>ein, was bedeutet, dass das erste Unterformular den ersten Datensatz der Datenherkunft anzeigt. Schließlich soll das Formular zwei Schaltflächen namens cmdNachOben <\/b>und cmdNachUnten <\/b>enthalten, mit denen der Benutzer zu den vorherigen beziehungsweise nächsten Datensätzen blättern kann, sowie eine Schaltfläche zum Anlegen eines neuen Datensatzes (cmdNeu<\/b>) – s. Bild 5.<\/p>\n Bild 5: Schaltflächen zum Blättern nach oben und unten und zum Anlegen eines neuen Datensatzes<\/span><\/b><\/p>\n Wenn das Formular gerade die ersten Datensätze anzeigt, soll die Schaltfläche cmdNachOben <\/b>natürlich deaktiviert sein, das Gleiche gilt für die Schaltfläche cmdNachUnten <\/b>auf der letzten Seite. Dies erledigen die letzten beiden Anweisungen der Prozedur. Die Bedingung für das Deaktivieren der Schaltfläche cmdNachUnten <\/b>lautet Not (intStartdatensatz + intElemente – 1 >= rst.RecordCount)<\/b>. Der Startdatensatz (in diesem Fall 1<\/b>) plus der Anzahl der angezeigten Datensätze (von der Prozedur UnterformulareFuellen <\/b>mit dem Parameter intElemente <\/b>zurückgeliefert) minus 1 <\/b>soll nicht größer oder gleich der Anzahl der Datensätze der Datenherkunft sein. Die Nach oben<\/b>-Schaltfläche wird immer aktiviert, wenn der Startdatensatz nicht der erste ist (intStartdatensatz = 1<\/b>).<\/p>\n Die Ereignisprozedur Form_Load <\/b>ruft die Routine UnterformulareFuellen <\/b>aus Listing 3 auf, um die entsprechenden Datensätze in den einzelnen Unterformularen anzuzeigen. Diese verwendet einen Parameter namens intElemente<\/b>, der die Anzahl der auf dieser Seite gefüllten Unterformulare zurückgeben soll. Die Prozedur durchläuft eine Do While<\/b>-Schleife, die erst abgebrochen wird, wenn das Ende des Recordsets erreicht ist, also keine Datensätze mehr in Unterformularen abzubilden sind, oder intElemente <\/b>kleiner als intUnterformulare <\/b>wird, also alle Unterformulare gefüllt sind. intElemente <\/b>wird gleich in der ersten Anweisung um 1 <\/b>erhöht. Dann ermittelt die Prozedur den Wert des Primärschlüsselfeldes des aktuellen Datensatzes und speichert diesen in der Variablen lngKundeID<\/b>.<\/p>\n Listing 3: Unterformulare füllen<\/span><\/b><\/p>\n Damit beginnen die Arbeiten am Unterformular: Dieses erhält zunächst eine Abfrage als Datensatzquelle, die den Kunden mit dem in lngKundeID <\/b>gespeicherten Primärschlüsselwert liefert. Die Visible<\/b>-Eigenschaft erhält den Wert True<\/b>, damit das Unterformularsteuerelement eingeblendet wird. Dies wiederholt die Schleife so lange, bis die Abbruchbedingung erfüllt ist.<\/p>\n Wenn alle Unterformulare vor dem Aufruf von UnterformulareFuellen <\/b>gefüllt sind und dann die letzte Seite aufgerufen wird und nicht alle Unterformulare mit neuen Datensätzen gefüllt werden, sollen die nicht benötigten Unterformulare natürlich geleert und ausgeblendet werden. Dies erledigen die Anweisungen innerhalb der folgenden If…Then<\/b>-Bedingung. Hat intElemente <\/b>nach dem Durchlaufen der Datensätze des Recordsets einen Wert kleiner als intUnterformulare <\/b>(was beispielsweise der Fall ist, wenn noch sechs Datensätze für die letzte Seite übrig sind, diese aber zwölf Datensätze anzeigen soll), ist die Bedingung erfüllt. In diesem Fall durchläuft eine For…Next<\/b>-Schleife alle Werte von intElemente +1 <\/b>bis zur Anzahl der Unterformulare (intUnterformulare<\/b>). Für die entsprechenden Unterformulare stellt die Prozedur dann die Eigenschaft Recordsource <\/b>auf eine leere Zeichenkette ein und blendet das Unterformularsteuerelement mit Visible = False <\/b>aus.<\/p>\n Nun soll die Prozedur noch ein Bezeichnungsfeld mit Informationen über die aktuell angezeigten Daten füllen. Dazu prüft es zunächst, ob die Eigenschaft rst.EOF<\/b> den Wert True <\/b>aufweist, also ob das Ende des Recordsets erreicht ist. In diesem Fall, der nur bei nicht komplett gefüllter letzter Seite eintritt, speichert die Prozedur in der Variablen intLetzterEintrag <\/b>die Anzahl der Datensätze des Recordsets, anderenfalls die aktuelle Position. So erhalten Sie im Bezeichnungsfeld lblEinträge <\/b>etwa einen Text wie 13-24 von 37<\/b>.<\/p>\n Die Schaltfläche cmdNachUnten <\/b>soll die nächsten x Datensätze in den vorhandenen Unterformularsteuerelementen anzeigen. Dazu löst sie die Ereignisprozedur aus Listing 4 aus. Diese verschiebt die Position des Datensatzzeigers des Recordsets aus rst <\/b>auf den Datensatz, der auf der aktuellen Seite gerade nicht mehr angezeigt wird. intStartdatensatz <\/b>enthält den Index des im ersten Unterformular angezeigten Datensatzes. Diesem fügt sie die Anzahl der Unterformulare hinzu und zieht 1 <\/b>ab (da AbsolutePosition 0-basiert ist). Für die zweite Seite wäre das also 1 + 12 – 1 = 12<\/b>. Der Datensatz des Recordsets mit dem Index 12 <\/b>(also der dreizehnte) soll also im ersten Unterformular erscheinen. Der Wert für intStartdatensatz <\/b>wird dann von 1 <\/b>auf 13 <\/b>geändert. Die Prozedur UnterformulareFuellen<\/b> stellt dann wiederum die Unterformulare auf die entsprechenden Datensätze ein. Schließlich erfolgt auch hier wieder die Aktivierung\/Deaktivierung der Schaltflächen cmdNachOben <\/b>und cmdNachUnten<\/b>.<\/p>\n Listing 4: Nach unten blättern<\/span><\/b><\/p>\n Die vorherige Seite zeigt ein Klick auf die Schaltfläche cmdOben <\/b>an (s. Listing 5). Diese prüft, ob der Wert von intStartdatensatz <\/b>größer als 0 <\/b>ist. In diesem Fall stellt sie die Position des Datensatzzeigers über die Eigenschaft AbsolutePosition <\/b>auf einen Wert ein, der dem aktuellen Wert von intStartdatensatz <\/b>(zum Beispiel 13<\/b>, wenn zuvor die zweite Seite von Datensätzen angezeigt wurde) die Anzahl der Unterformulare (intUnterformulare<\/b>) und den Wert 1 <\/b>abzieht (um dem 0-basierten Wert von AbsolutePosition <\/b>gerecht zu werden). Anderenfalls erhält AbsolutePosition <\/b>den Wert 0<\/b>, was der ersten Seite entspricht. Die Prozedur UnterformulareFuellen <\/b>aktualisiert wieder die Unterformulare und die übrigen Anweisungen aktivieren beziehungsweise deaktivieren die Schaltflächen cmdNachUnten <\/b>und cmdNachOben<\/b>.<\/p>\n Listing 5: Nach oben blättern<\/span><\/b><\/p>\n Ein Klick auf die Schaltfläche cmdNeu <\/b>soll einen neuen Datensatz hinzufügen. In herkömmlichen Formularen ist dies einfach: Sie müssen dazu einfach nur den Datensatzzeiger auf den neuen, leeren Datensatz verschieben und legen los. Hier ist es nicht so einfach, denn die angezeigten Unterformulare zeigen ja jeweils bereits einen Datensatz an. Es wäre recht ergonomisch, wenn für einen neuen Datensatz ein neues Unterformular angezeigt werden könnte, das dann einen leeren Datensatz zum Bearbeiten bereitstellt. Dazu müssen wir also zunächst einmal zur letzten Seite wechseln, da neue Datensätze ja meist hinten angefügt werden und nicht einfach mittendrin. Dann prüfen wir, ob die letzte Seite nicht zufällig komplett gefüllt ist, was dazu führt, dass wir dort kein Unterformular mehr für den neuen Datensatz nutzen können, und wechseln gegebenenfalls zu einer komplett leeren Seite und zeigen dort das leere Unterformular an. All dies erledigt die Prozedur aus Listing 6.<\/p>\n Listing 6: Neuen Datensatz hinzufügen<\/span><\/b><\/p>\n Die Prozedur prüft zunächst, ob die Unterformulare aller Seiten komplett gefüllt sind. In diesem Fall liefert die Division der Anzahl der Datensätze durch die Anzahl der Unterformulare je Seite den Rest 0<\/b>. In diesem Fall stellt die Prozedur den Wert für intStartdatensatz <\/b>auf einen noch nicht vorhandenen Datensatz ein (rst.RecordCount + 1<\/b>), bei 36 vorhandenen Datensätzen also etwa auf 37<\/b>. AbsolutePosition<\/b> wird wegen der 0-Basis wieder auf intStartdatensatz – 1 <\/b>eingestellt. Dann ruft die Prozedur die Routine Unterformulare-Fuellen <\/b>auf, was in diesem Fall dazu führt, dass nur ein Unterformular eingeblendet ist, dieses aber den letzten Datensatz der Datenherkunft anzeigt (etwa wie in Bild 6).<\/p>\n Bild 6: Ein für das Anlegen eines neuen Datensatzes vorgesehenes Unterformular, …<\/span><\/b><\/p>\n Das geht nicht anders, weil wir AbsolutePosition <\/b>nicht etwa durch den Wert 36 <\/b>auf einen neuen, leeren Datensatz positionieren können – dies würde zu einem Fehler führen. Stattdessen sorgen die Anweisungen hinter der Select Case<\/b>-Bedingung dafür, dass das Unterformular für den neuen Datensatz tatsächlich einen neuen, leeren Datensatz anzeigt. Dazu stellt die Routine die Eigenschaft RecordSource <\/b>auf eine Abfrage auf Basis der Tabelle tblKunden <\/b>ein, die aber wegen des Kriteriums 1=2 <\/b>keine Datensätze zurückliefert. Außerdem blendet die Prozedur das Unterformular ein und aktiviert es, bevor es wie üblich die beiden Schaltflächen cmdNachUnten <\/b>und cmdNachOben <\/b>aktiviert\/deaktiviert (s. Bild 7).<\/p>\n Bild 7: … das dann mit dem neuen, leeren Datensatz gefüllt wird und bereit zur Eingabe ist.<\/span><\/b><\/p>\n Für den Fall, dass der Benutzer auf die Schaltfläche cmdNeu <\/b>klickt, während auf der letzten Seite noch mindestens ein Unterformular keinen Datensatz anzeigt, verwenden wir für den neuen Datensatz einfach das nächste freie Unterformular auf der letzten Seite. Dazu stellt der zweite Teil der Select Case<\/b>-Bedingung die Variable intStartdatensatz <\/b>auf den Wert rst.RecordCount – rst.RecordCount Mod intUnterformular + 1 <\/b>ein, was den Index des ersten Eintrags auf der letzten Seite ermittelt, im Falle von 38 Einträgen also etwa 38 – 38 Mod 12 + 1 = 37<\/b>. Damit füllt die Prozedur dann die letzte Seite, bevor das Unterformular für den neuen Datensatz vorbereitet wird.<\/p>\n Was geschieht nun, nachdem der Benutzer die Felder des neuen Datensatzes gefüllt und diesen gespeichert hat üblicherweise sind dort keine Schritte mehr nötig. Aber wir müssen das Recordset aus der Variablen rst<\/b> auf dem aktuellen Stand halten, da wir dieses für das Füllen der Unterformulare verwenden. Dies gelingt nur mit der Requery<\/b>-Methode. Um überhaupt zu registrieren, wann der Benutzer den neuen Datensatz speichert, legen Sie für das Ereignis Nach Einfügung <\/b>des Unterformulars die folgende Ereignisprozedur an:<\/p>\n Diese ruft die Prozedur DatensatzHinzugefuegt <\/b>des Hauptformulars auf, die wiederum so aussieht:<\/p>\n Die Prozedur aktualisiert das Recordset rst <\/b>mit der Requery<\/b>-Methode und verschiebt den Datensatzzeiger dann auf den letzten und wieder auf den ersten Datensatz, damit die folgende Zuweisung des Wertes intStartdatensatz – 1<\/b> an die Eigenschaft AbsolutePosition <\/b>des Recordsets keinen Fehler auslöst.<\/p>\n Nach der Aktualisierung des Recordsets kann die Routine UnterformulareFuellen <\/b>dann die Unterformulare der aktuellen Seite füllen.<\/p>\n Damit der Benutzer einen Datensatz löschen kann, haben wir die Schaltfläche cmdLoeschen <\/b>zum Unterformular hinzugefügt. Diese ruft die Methode DatensatzLoeschen <\/b>im Hauptformular auf:<\/p>\n Diese ist als Public deklariert, damit sie vom Unterformular aus aufgerufen werden kann, und enthält die folgenden beiden Anweisungen:<\/p>\n Diese markieren und löschen den aktuell im Unterformular angezeigten Datensatz. Auch hier müssen wir noch ein wenig nacharbeiten, damit das Unterformular, das den gelöschten Datensatz angezeigt hat, ausgeblendet wird. Dazu fügen wir wiederum eine Ereignisprozedur zum Unterformular hinzu, die diesmal durch das Ereignis Nach Löschbestätigung <\/b>ausgelöst wird:<\/p>\n Die hier aufgerufene Prozedur des Hauptformulars sieht so aus:<\/p>\n Sie stellt, falls der zu löschende Eintrag allein auf der aktuellen Seite erscheint, den Startdatensatz auf den Index des ersten Datensatzes der vorherigen Seite ein. Danach aktualisiert sie das Recordset und füllt die Unterformulare neu.<\/p>\n Die Löschen<\/b>-Schaltfläche soll bei Datensätzen, die gerade erst angelegt werden, deaktiviert sein, da das Löschen sonst einen Fehler auslöst. Dies erledigen wir mit der folgenden Prozedur, die durch das Ereignis Beim Anzeigen <\/b>des Unterformulars ausgelöst wird und die den Wert der Eigenschaft Enabled <\/b>in Abhängigkeit von NewRecord <\/b>einstellt:<\/p>\nUnterformulare hinzufügen<\/h2>\n
Public Sub <\/span>UnterformulareAnlegen(strForm As String<\/span>, intX As Integer<\/span>, intY As Integer<\/span>, lngBreite As Long<\/span>, _\r\n lngHoehe As Long<\/span>, lngAbstandX As Long<\/span>, lngAbstandY As Long<\/span>, Optional<\/span> strSubform As String<\/span>)\r\n Dim <\/span>frm As <\/span>Form\r\n Dim <\/span>ctl As <\/span>Control\r\n Dim <\/span>i As Integer<\/span>\r\n Dim <\/span>x As Integer<\/span>\r\n Dim <\/span>y As Integer<\/span>\r\n On Error Resume Next<\/span>\r\n DoCmd.Close acForm, strForm\r\n On Error GoTo<\/span> 0\r\n DoCmd.OpenForm strForm, acDesign\r\n Set<\/span> frm = Forms(strForm)\r\n For i = frm.Controls.Count - 1 To 0 Step -1\r\n Set<\/span> ctl = frm.Controls(i)\r\n Select Case ctl.ControlType\r\n Case <\/span>acLabel, acSubform\r\n DeleteControl frm.Name, ctl.Name\r\n End Select<\/span>\r\n Next<\/span> i\r\n i = 0\r\n For y = 1 To intY\r\n For x = 1 To intX\r\n i = i + 1\r\n Set<\/span> ctl = CreateControl(frm.Name, acSubform, acDetail, , , lngAbstandX + (lngAbstandX + lngBreite) _\r\n * (x - 1), lngAbstandY + (lngAbstandX + lngHoehe) * (y - 1), lngBreite, lngHoehe)\r\n ctl.Name = \"sfm\" & Format(i, \"00\")\r\n If <\/span>Len<\/span>(strSubform) > 0 Then<\/span>\r\n ctl.SourceObject = strSubform\r\n End If<\/span>\r\n Next<\/span> x\r\n Next<\/span> y\r\nEnd Sub<\/span><\/pre>\nUnterformulareAnlegen \"frmKundenNebeneinander\", 3, 4, 4000, 3000, 100, 100, \"sfmKundenNebeneinander\"<\/pre>\n
![\"Frisch](\"..\/fileadmin\/_temp_\/2015_06\/pic_1010_002.png\")
<\/p>\nUnterformular anlegen<\/h2>\n
![\"Das](\"..\/fileadmin\/_temp_\/2015_06\/pic_1010_003.png\")
<\/p>\n![\"Gleicher](\"..\/fileadmin\/_temp_\/2015_06\/pic_1010_004.png\")
<\/p>\nUnterformulare mit verschiedenen Datensätzen füllen<\/h2>\n
Private Sub <\/span>Form_Load()\r\n Dim <\/span>intElemente As Integer<\/span>\r\n Dim <\/span>j As Integer<\/span>\r\n Set<\/span> db = CurrentDb\r\n Set<\/span> rst = db.OpenRecordset(\"SELECT * FROM tblKunden\", dbOpenDynaset)\r\n intStartdatensatz = 1\r\n UnterformulareFuellen intElemente\r\n Me!cmdNachUnten.Enabled = Not<\/span> (intStartdatensatz + intElemente - 1 >= rst.RecordCount)\r\n Me!cmdNachOben.Enabled = Not<\/span> intStartdatensatz = 1\r\nEnd Sub<\/span><\/pre>\nDim <\/span>db As <\/span>DAO.Database\r\nDim <\/span>rst As <\/span>DAO.Recordset\r\nDim <\/span>intStartdatensatz As Integer<\/span><\/pre>\n![\"Schaltflächen](\"..\/fileadmin\/_temp_\/2015_06\/pic_1010_005.png\")
<\/p>\nUnterformulare füllen<\/h2>\n
Private Sub <\/span>UnterformulareFuellen(intElemente As Integer<\/span>)\r\n Dim <\/span>lngKundeID As Long<\/span>\r\n Dim <\/span>intLetzterEintrag As Integer<\/span>\r\n Dim <\/span>j As Integer<\/span>\r\n Do While<\/span> Not<\/span> rst.EOF And intElemente < intUnterformulare\r\n intElemente = intElemente + 1\r\n lngKundeID = rst!KundeID\r\n With<\/span> Me(\"sfm\" & Format(intElemente, \"00\"))\r\n .Form.RecordSource = \"SELECT * FROM tblKunden WHERE KundeID = \" & lngKundeID\r\n .Visible = True<\/span>\r\n End With<\/span>\r\n rst.MoveNext<\/span>\r\n Loop<\/span>\r\n If <\/span>intElemente < intUnterformulare Then<\/span>\r\n For j = intElemente + 1 To intUnterformulare\r\n With<\/span> Me(\"sfm\" & Format(j, \"00\"))\r\n .Form.RecordSource = \"\"\r\n .Visible = False<\/span>\r\n End With<\/span>\r\n Next<\/span> j\r\n End If<\/span>\r\n If <\/span>rst.EOF = True<\/span> Then<\/span>\r\n intLetzterEintrag = rst.RecordCount\r\n Else<\/span>\r\n intLetzterEintrag = rst.AbsolutePosition\r\n End If<\/span>\r\n Me!lblEintraege.Caption = intStartdatensatz & \"-\" & intLetzterEintrag & \" von \" & rst.RecordCount\r\nEnd Sub<\/span><\/pre>\nNächste Seite anzeigen<\/h2>\n
Private Sub <\/span>cmdNachUnten_Click()\r\n Dim <\/span>intElemente As Integer<\/span>\r\n rst.AbsolutePosition = intStartdatensatz + intUnterformulare - 1\r\n intStartdatensatz = intStartdatensatz + intUnterformulare\r\n UnterformulareFuellen intElemente\r\n Me!cmdNachUnten.Enabled = Not<\/span> (intStartdatensatz + intElemente > rst.RecordCount)\r\n Me!cmdNachOben.Enabled = Not<\/span> intStartdatensatz = 1\r\nEnd Sub<\/span><\/pre>\nVorherige Seite anzeigen<\/h2>\n
Private Sub <\/span>cmdNachOben_Click()\r\n Dim <\/span>intElemente As Integer<\/span>\r\n If <\/span>intStartdatensatz > 0 Then<\/span>\r\n rst.AbsolutePosition = intStartdatensatz - intUnterformulare - 1\r\n Else<\/span>\r\n rst.AbsolutePosition = 0\r\n End If<\/span>\r\n UnterformulareFuellen intElemente\r\n intStartdatensatz = intStartdatensatz + intElemente - intUnterformulare * 2\r\n Me!cmdNachUnten.Enabled = Not<\/span> (intStartdatensatz >= rst.RecordCount)\r\n Me!cmdNachOben.Enabled = Not<\/span> intStartdatensatz = 1\r\nEnd Sub<\/span><\/pre>\nNeuen Datensatz hinzufügen<\/h2>\n
Private Sub <\/span>cmdNeu_Click()\r\n Dim <\/span>intElemente As Integer<\/span>\r\n Select Case rst.RecordCount Mod<\/span> intUnterformulare\r\n Case <\/span>0\r\n intStartdatensatz = rst.RecordCount + 1\r\n rst.AbsolutePosition = intStartdatensatz - 1\r\n UnterformulareFuellen 0\r\n Case Else<\/span>\r\n intStartdatensatz = rst.RecordCount - rst.RecordCount Mod<\/span> intUnterformulare + 1\r\n rst.AbsolutePosition = intStartdatensatz - 1\r\n UnterformulareFuellen intElemente\r\n End Select<\/span>\r\n With<\/span> Me(\"sfm\" & Format(intElemente + 1, \"00\"))\r\n .Form.RecordSource = \"SELECT * FROM tblKunden WHERE 1=2\"\r\n .Visible = True<\/span>\r\n .SetFocus\r\n End With<\/span>\r\n Me!cmdNachUnten.Enabled = Not<\/span> (intStartdatensatz + intElemente - 1 >= rst.RecordCount)\r\n Me!cmdNachOben.Enabled = Not<\/span> intStartdatensatz = 1\r\nEnd Sub<\/span><\/pre>\n![\"Ein](\"..\/fileadmin\/_temp_\/2015_06\/pic_1010_006.png\")
<\/p>\n![\"...](\"..\/fileadmin\/_temp_\/2015_06\/pic_1010_007.png\")
<\/p>\nNach dem Hinzufügen<\/h2>\n
Private Sub <\/span>Form_AfterInsert()\r\n Me.Parent.DatensatzHinzugefuegt\r\nEnd Sub<\/span><\/pre>\nPublic Sub <\/span>DatensatzHinzugefuegt()\r\n With<\/span> rst\r\n .Requery\r\n .MoveLast\r\n .MoveFirst\r\n .AbsolutePosition = intStartdatensatz - 1\r\n End With<\/span>\r\n UnterformulareFuellen 0\r\nEnd Sub<\/span><\/pre>\nLöschen eines Datensatzes<\/h2>\n
Private Sub <\/span>cmdLoeschen_Click()\r\n Me.Parent.DatensatzLoeschen\r\nEnd Sub<\/span><\/pre>\nPublic Sub <\/span>DatensatzLoeschen()\r\n RunCommand acCmdSelectRecord\r\n RunCommand acCmdDeleteRecord\r\nEnd Sub<\/span><\/pre>\nPrivate Sub <\/span>Form_AfterDelConfirm(Status As Integer<\/span>)\r\n Me.Parent.DatensatzGeloescht\r\nEnd Sub<\/span><\/pre>\nPublic Sub <\/span>DatensatzGeloescht()\r\n Me!cmdNeu.SetFocus\r\n Select Case rst.RecordCount Mod<\/span> intUnterformulare\r\n Case <\/span>1\r\n intStartdatensatz = _\r\n intStartdatensatz - intUnterformulare\r\n End Select<\/span>\r\n With<\/span> rst\r\n .Requery\r\n .MoveLast\r\n .MoveFirst\r\n .AbsolutePosition = intStartdatensatz - 1\r\n End With<\/span>\r\n UnterformulareFuellen 0\r\nEnd Sub<\/span><\/pre>\nAktivieren und Deaktivieren der Löschen-Schaltfläche<\/h2>\n
Private Sub <\/span>Form_Current()\r\n Me!cmdLoeschen.Enabled =