<\/p>\n
Normalerweise verwendet man verschiedene Registerkarten, um unterschiedliche Daten anzuzeigen – beispielsweise auf dem Hauptformular die Basis-Daten zu einem Kunden wie Kundennummer und Name und auf den Registerkarten Informationen wie die Lieferanschrift, die Rechnungsanschrift und weitere Daten. Wir wollen in diesem Beitrag einmal zeigen, wie Sie verschiedene Datensätze der gleichen Tabelle auf Registerseiten anzeigen – beispielsweise, um die letzten zehn angezeigten Kunden immer schnell aufschlagen zu können.<\/b><\/p>\n
Damit wäre auch schon die Anzahl der zu verwendenden Registerseiten festgelegt – nämlich zehn. Irgendwann würde es nämlich mit steigender Anzahl von Registerreitern etwas unübersichtlich.<\/p>\n
Wir wollen also ein Hauptformular erstellen, das hauptsächlich ein Registersteuerelement enthält, das auf seinen zehn Registerseiten jeweils das gleiche Unterformular mit Daten aus der Tabelle tblKunden <\/b>der Beispieldatenbank anzeigt.<\/p>\n
Da wäre nun noch zu klären, wie wir dafür sorgen, dass überhaupt ein Kundendatensatz dorthin gelangt. Am einfachsten wäre es, eine kleine Suchfunktion samt Ergebnisliste in Form eines Listenfeldes im Hauptformular unterzubringen. Per Doppelklick auf einen der Einträge im Listenfeld soll der gewählte Kunde dann auf der Registerseite ganz links erscheinen. Die übrigen Kunden im Registersteuerelement sollen dann, sofern bereits vorhanden, auf die Registerseiten rechts davon verschoben werden.<\/p>\n
Sobald ein neuer Kunde ausgewählt wird, soll bei komplett gefüllten Registerseiten also der letzte Kunde rechts rausfallen. Die vollständige Lösung sieht dann später wie in Bild 1 aus.<\/p>\n
![\"Die](\"..\/fileadmin\/_temp_\/2015_01\/pic_967_009.png\")
<\/p>\n
Bild 1: Die fertige Lösung<\/span><\/b><\/p>\n Unterformular erstellen<\/b><\/p>\n Das Unterformular der Lösung soll sfmKunden <\/b>heißen und die Tabelle tblKunden<\/b> als Datenherkunft nutzen. Ziehen Sie alle Felder der Datenherkunft aus der Feldliste in den Detailbereich des Formulars und teilen Sie diese etwa wie in Bild 2 auf. Stellen Sie die Eigenschaften Bildlaufleisten<\/b>, Navigationsschaltflächen<\/b>, Datensatzmarkierer <\/b>und Trennlinien <\/b>auf den Wert Nein <\/b>ein.<\/p>\n Bild 2: Das Unterformular sfmKunden<\/span><\/b><\/p>\n Kunden auswählen<\/b><\/p>\n Die Auswahl der Kunden soll per Doppelklick auf die Einträge eines Listenfeldes erfolgen. Dieses soll wiederum nach der Eingabe in ein einfaches Suchfeld gefiltert werden.<\/p>\n Dazu fügen Sie dem Hauptformular namens frmKundenregister <\/b>zunächst ein Textfeld namens txtSuche <\/b>und ein Listenfeld namens lstKunden <\/b>zu.<\/p>\n Die Eigenschaften Datensatzmarkierer<\/b>, Navigationsschaltflächen<\/b>, Trennlinien <\/b>und Bildlaufleisten <\/b>des Formulars sollten den Wert Nein <\/b>enthalten.<\/p>\n Für das Listenfeld hinterlegen Sie ebenfalls die Tabelle tblKunden<\/b> als Datenherkunft. Das Listenfeld soll die ersten vier Felder der Datensatzherkunft enthalten, daher stellen Sie die Eigenschaft Spaltenanzahl <\/b>auf den Wert 4 ein. Die Spaltenbreiten sind mit 0cm;2cm;6cm;6cm vernünftig ausgelegt. Die erste Spalte enthält ja nur das Primärschlüsselfeld, das als gebundene Spalte dienen soll – dieses braucht nicht sichtbar zu sein.<\/p>\n Bis hierhin sieht das Hauptformular im Entwurf wie in Bild 3 aus. Damit das Listenfeld nur solche Einträge anzeigt, die in einem der drei Felder Kundencode<\/b>, Firma <\/b>oder Kontaktperson <\/b>den im Suchfeld txtSuche <\/b>eingegebenen Ausdruck enthalten, legen wir für das Ereignis Bei änderung <\/b>des Textfeldes eine entsprechende VBA-Prozedur an.<\/p>\n Bild 3: Das Hauptformular mit Such- und Listenfeld<\/span><\/b><\/p>\n Diese sieht wie in Listing 1 aus und stellt zunächst einen geeigneten Suchausdruck in Form einer SELECT<\/b>-Anweisung zusammen. Diese wird dann der Eigenschaft RowSource <\/b>des Listenfeldes zugewiesen.<\/p>\n Listing 1: Filtern des Listenfeldes nach dem im Suchfeld eingegebenen Ausdruck<\/span><\/b><\/p>\n Bild 4 zeigt die Suchfunktion mit dem entsprechenden Suchergebnis im Listenfeld.<\/p>\n Bild 4: Die Suchfunktion des Beispielformulars<\/span><\/b><\/p>\n Registersteuerelement anlegen<\/b><\/p>\n Damit kommen wir zum interessanten Teil und fügen zunächst ein neues Registersteuerelement zum Formular frmKundenregister <\/b>hinzu. Dieses soll natürlich unter dem Listenfeld landen und die gleiche Breite wie dieses einnehmen. Das Registersteuerelement soll den Namen regKunden <\/b>erhalten.<\/p>\n Nach dem Hinzufügen des Registersteuer-elements kommt das erste Unterformular an die Reihe. Genau genommen fügen wir dort zunächst einmal ein Unterformular-Steuerelement ein. Dazu klicken Sie auf den linken Registerreiter, dann auf die Schaltfläche zum Hinzufügen eines Unterformular-Steuerelements und fügen dieses dann schließlich in die erste Seite des Registersteuerelements ein.<\/p>\n Die Registerseite sollte dabei wie in Bild 5 schwarz hinterlegt erscheinen. Entfernen Sie dann das Bezeichnungsfeld und stellen Sie die Eigenschaft Name <\/b>auf den Wert sfm01 <\/b>ein (später werden wir noch weitere solcher Unterformulare einfügen). Anschließend ändern Sie die Eigenschaft Rahmenart <\/b>des Unterformular-Steuerelements auf den Wert Transparent <\/b>(s. Bild 6).<\/p>\n Bild 5: Hinzufügen des Unterformulars zur ersten Registerkarte<\/span><\/b><\/p>\n Bild 6: Der Rahmen des Unterformulars soll transparent erscheinen.<\/span><\/b><\/p>\n Kundendaten auf Registerseite anzeigen<\/b><\/p>\n Nun können wir uns um die Füllung des Unterformulars mit den Daten für den ersten im Listenfeld doppelt angeklickten Kunden-Datensatz kümmern. Legen Sie also für das Listenfeld eine Ereignisprozedur an, die durch das Ereignis Beim Doppelklicken <\/b>ausgelöst wird.<\/p>\n Diese Prozedur sieht wie in Listing 2 aus und stellt zunächst die Beschriftung der ersten Registerseite des Registersteuerelements auf den Wert der Listenfeldspalte mit dem Index 2 <\/b>ein, also der dritten Spalte. Diese liefert den Wert des Feldes Firma<\/b> der Tabelle tblKunden<\/b>.<\/p>\n Listing 2: Anzeigen des angeklickten Kunden im Registersteuerelement<\/span><\/b><\/p>\n Danach folgen zwei Anweisungen, die sich mit dem Unterformular-Steuerelement beschäftigen: Die erste legt das Formular sfmKunden <\/b>als das im Unterformular-Steuerelement anzuzeigende Objekt fest. Die zweite stellt die Datenherkunft für das Unterformular ein.<\/p>\n Dabei handelt es sich um eine SQL-Abfrage, die genau den Datensatz der Tabelle tblKunden <\/b>liefert, den der Benutzer soeben im Listenfeld lstKunden <\/b>doppelt angeklickt hat. Das Ergebnis sieht aktuell wie in Bild 7 aus.<\/p>\n Bild 7: Anzeige des soeben doppelt angeklickten Kunden-Datensatzes<\/span><\/b><\/p>\n Weitere Registerseiten füllen<\/b><\/p>\n Nun haben wir die erste Registerseite gefüllt. Dies funktioniert auch, wenn Sie danach andere Einträge des Listenfeldes anklicken. Allerdings fehlt noch die entscheidende Funktion: Nämlich das Verschieben des aktuell auf der ersten Registerseite angezeigten Kunden auf die zweite Seite, wenn die erste Seite einen neuen Kunden anzeigen soll.<\/p>\n Dazu wollen wir zunächst die Vorarbeiten erledigen – nämlich das Anlegen der übrigen neun Registerseiten samt Unterformular-Steuerelementen. Diese fügen Sie jeweils in die übrigen Registerseiten ein und benennen diese durchlaufend mit sfm02<\/b>, sfm03 <\/b>und so weiter bis sfm10<\/b>.<\/p>\n Nachdem Sie geprüft haben, dass die Unterformular-Steuerelemente alle gleich ausgerichtet sind und die gleiche Größe haben, kümmern wir uns um den Code.<\/p>\n Hier ist zunächst zu beachten, dass das Registersteuerelement im Startzustand, also wenn der Benutzer noch keinerlei Kunden-Datensätze darin angezeigt hat, auch keine Daten anzeigen soll. Genau genommen wäre es praktisch, wenn der Benutzer per Bezeichnungsfeld darauf aufmerksam gemacht wird, dass er per Doppelklick einen Kunden im Unterformular anzeigen kann.<\/p>\n Vorher müssen wir uns allerdings noch überlegen, wie wir die zuletzt aufgerufenen Kundendatensätze überhaupt speichern, um diese später wiederherstellen zu können. Da diese Information sitzungsübergreifend verfügbar sein soll, speichern wir diese also einfach in einer Tabelle namens tblLetzteKunden<\/b>. Diese Tabelle sieht im Entwurf wie in Bild 8 aus. Sie speichert neben dem Primärschlüsselwert, der benötigt wird, um die Reihenfolge des Anlegens zu dokumentieren, nur den Primärschlüsselwert des jeweiligen Datensatzes der Tabelle tblKunden<\/b>. Damit jeder Kundendatensatz hier nur einmal vermerkt wird, stellen wir für das Feld LetzterKunde <\/b>noch den Wert Ja (Ohne Duplikate) <\/b>für die Eigenschaft Indiziert <\/b>ein.<\/p>\n Bild 8: Tabelle zum Speichern der zuletzt angezeigten Kunden<\/span><\/b><\/p>\n Damit eventuell gelöschte Datensätze aus der Tabelle tblKunden <\/b>auch aus der Tabelle tblLetzteKunden <\/b>entfernt werden, legen wir noch eine Beziehung zwischen den beiden Tabellen an und versehen diese mit referenzieller Integrität und Löschweitergabe (s. Bild 9).<\/p>\n Bild 9: Einrichten einer Löschweitergabe für die Kundentabellen<\/span><\/b><\/p>\n Kunden über die Registerseiten verteilen<\/b><\/p>\n Damit begeben wir uns an eine neue Version der Ereignisprozedur lstKunden_DblClick<\/b> (s. Listing 3). Diese speichert zunächst den Wert des Feldes Kunde-ID <\/b>aus dem Listenfeld in der Variablen lngKundeID <\/b>zwischen.<\/p>\n <\/p>\n Listing 3: Anzeigen der zuletzt gewählten Kunden auf verschiedenen Registerseiten<\/span><\/b><\/p>\n Dann löscht sie einen eventuell bereits vorhandenen Datensatz in der Tabelle tblLetzteKunden<\/b>, da dieser im nächsten Schritt neu angelegt wird. Warum nicht einfach prüfen, ob ein solcher Datensatz vorhanden ist und diesen beibehalten Weil der zuletzt per Doppelklick ausgewählte Datensatz ja als aktuellster Datensatz gespeichert und ganz links im Registersteuerelement angezeigt werden soll. Dies erreichen wir am einfachsten über den Autowert-Primärschlüssel der Tabelle tblLetzteKunden<\/b>: Ein neuer Datensatz erhält ja automatisch den höchsten Wert und wird so über die Sortierung nach dem Primärschlüsselwert als zuletzt gewählter Eintrag erkannt.<\/p>\n Danach erstellt die Prozedur ein Recordset auf Basis der Tabelle tblLetzteKunden<\/b>, wobei sie die Daten absteigend nach dem Feld LetzterKundeID <\/b>sortiert und nur zehn Datensätze liefert – mehr benötigen wir ja nicht, um die zehn Datensätze für die zehn Registerseiten zu ermitteln.<\/p>\n Danach durchläuft die Prozedur die Datensätze dieses Recordsets in einer Do While<\/b>-Schleife. Sollte die Tabelle weniger als zehn Datensätze enthalten, wird das Recordset natürlich auch mit weniger als zehn Datensätzen gefüllt. Dann stellt die Prozedur die Sichtbarkeit der Registerseite mit dem Indexwert aus der Variablen intCounter <\/b>auf True <\/b>ein. Beim ersten Durchlauf enthält intCounter <\/b>an dieser Stelle den Wert 0<\/b>, was der ersten Registerseite entspricht. Auf die gleiche Weise schreibt sie den Wert des Feldes Firma <\/b>für diesen Datensatz der Tabelle tblKunden<\/b>, den sie per DLook-up <\/b>ermittelt, in die Eigenschaft Caption <\/b>der Registerseite.<\/p>\n Danach addiert die Prozedur den Wert 1 <\/b>zur Variablen intCounter <\/b>hinzu. Diesen brauchen wir nicht nur innerhalb der Do While<\/b>-Schleife für den Zugriff auf die Registerseiten über deren Index, sondern auch, um uns zu merken, wie viele Registerseiten mit Daten gefüllt werden. Die übrigen Registerseiten müssen ja später geleert werden, damit nur die gewünschten Daten erscheinen.<\/p>\n Warum erhöhen wir intCounter <\/b>an dieser Stelle und nicht später Weil wir in der nächsten Anweisung das Unterformular-Steuerelement referenzieren müssen, das wir mit dem richtigen Unterformular und der passenden Datenherkunft versehen müssen. Und da wir diese nach dem Schema sfm01<\/b>, sfm02 <\/b>und so weiter benannt haben und nicht 0-basiert, erhöhen wir intCounter <\/b>praktischerweise an dieser Stelle um den Wert 1<\/b>.<\/p>\n Als Datenherkunft für das jeweilige Formular verwenden wir eine SELECT<\/b>-Anweisung, welche genau den Datensatz der Tabelle tblKunden <\/b>enthält, dessen Primärschlüsselwert im aktuellen Recordset der Do While<\/b>-Schleife gespeichert ist. Danach steuert die Do While<\/b>-Schleife den nächsten Datensatz an und beginnt von vorn.<\/p>\n Dies geschieht entsprechend der Anzahl der Datensätze im Recordset. Wenn dieses sechs Datensätze enthält, werden also sechs Registerseiten mit Kundendaten gefüllt. Was aber, wenn vorher schon einmal mehr Registerseiten gefüllt waren als jetzt – beispielsweise, weil zwischenzeitlich die Daten der Tabelle tblLetzteKunden <\/b>gelöscht wurden Dann müssen wir nun dafür sorgen, dass die nicht benötigten Registerseiten auch wieder geleert werden.<\/p>\n Dies erledigen die übrigen Zeilen der Ereignisprozedur lstKunden_DoubleClick<\/b>. Diese durchläuft dann eine For…Next<\/b>-Schleife über alle Zahlen von dem Wert aus intGefuellt <\/b>bis 9<\/b>. Wenn zuvor also etwa vier Registerseiten samt Unterformularen gefüllt wurden, dann durchläuft die Schleife nun die Werte von 4 <\/b>bis 9<\/b>, also die verbleibenden sechs.<\/p>\n Innerhalb dieser Schleife stellt die Prozedur die Visible<\/b>-Eigenschaft der Registerseiten auf False <\/b>ein und blendet diese damit aus. Außerdem werden die Unterformular-Steuerelemente geleert.<\/p>\n Dieser Ansatz funktioniert wie gewünscht: Die zuletzt ausgewählten Kunden erscheinen auf den Registerseiten und werden über die Registerreiter schön übersichtlich angezeigt.<\/p>\n Die Sache hat nur einen Haken: Das Füllen von bis zu zehn Unterformular-Steuerelementen mit Unterformularen und Daten dauert einige Augenblicke und das Formular flackert auch recht ordentlich.<\/p>\n Wir müssen also noch etwas an der Performance arbeiten.<\/p>\n Optimierung der Anzeige der Unterformulare<\/b><\/p>\n Hier gibt es gleich mehrere Ansätze. Der erste kommt einem automatisch in den Sinn, wenn es um mehrere Unterformulare im Registersteuerelement geht. Man könnte hier dafür sorgen, dass die Inhalte der Unterformulare erst eingelesen werden, wenn das jeweilige Unterformular auch erscheint.<\/p>\n Der zweite Ansatz ist: Müssen die Unterformulare überhaupt geleert werden, also muss man die Eigenschaft SourceObject <\/b>(Herkunftsobjekt<\/b>) eigentlich immer auf eine leere Zeichenkette einstellen und dann erneut mit dem Wert sfmKunden <\/b>füllen Sicher nicht, wenn ohnehin immer das gleiche Unterformular angezeigt wird.<\/p>\n Dies schauen wir uns zuerst an. Wir entfernen also die folgende Zeile aus der Do While<\/b>-Schleife:<\/p>\n Außerdem löschen wir die folgenden Zeilen aus der If…Then<\/b>-Schleife:<\/p>\n Der erste Testlauf danach zeigt: Das war schon die halbe Miete! Damit haben wir sicher 50% Zeit herausgeholt.<\/p>\n Allerdings flackert es immer noch recht ordentlich, wenn man bei zehn gefüllten Registerseiten die Seite vorne links neu füllt und alle Elemente um eines nach rechts verschiebt.<\/p>\n Aber auch hier gibt es einen Ansatzpunkt: Warum nicht einfach die Reihenfolge der Registerseiten so verschieben, dass das letzte Element an die erste Stelle rückt und mit den Daten des zuletzt angeklickten Kundendatensatzes gefüllt wird und die übrigen Registerseiten alle um eine Position nach rechts verschoben werden<\/p>\n Genau genommen gelingt dies sogar noch viel einfacher: Wir brauchen lediglich die Eigenschaft PageIndex <\/b>des letzten Elements auf den Wert 0 <\/b>einzustellen und alle übrigen Elemente rutschen eine Position weiter nach rechts.<\/p>\n Nun müssen wir nur noch die ganz links befindliche Registerseite sichtbar machen und aktualisieren. Dazu ermitteln wir zunächst den Namen des Unterformulars, das sich auf dieser Registerseite befindet. Diesen erhalten wir mit folgender Anweisung:<\/p>\n Allerdings können wir ihm Rahmen dieser Umstellung gleich noch eine Menge weiterer Optimierungen vornehmen. Zusammengefasst kommen wir dann zu der nachfolgend vorgestellten Variante.<\/p>\n Einlesen beim Laden<\/b><\/p>\n Der erste Teil der fertigen Lösung besteht aus dem Laden der bereits in der Tabelle tblLetzteKunden<\/b> gespeicherten Einträge und dem Einstellen des Registersteuerelements auf die dort vorgefundenen Datensätze – dies alles gleich beim öffnen des Formulars.<\/p>\n Das Ereignis Beim Laden<\/b> löst die Prozedur aus Listing 4 aus. Diese öffnet ein Recordset mit den neuesten zehn Einträgen der Tabelle tblLetzteKunden <\/b>und durchläuft dieses dann in einer Do While<\/b>-Schleife. Darin stellt sie zunächst die Eigenschaft Visible <\/b>der Registerseite mit dem in der Variablen intGefuellt <\/b>gespeicherten Indexwert auf True <\/b>und blendet diese somit ein. Die Variable intGefuellt <\/b>wird mit jedem Schleifendurchlauf um eins erhöht – aber erst weiter unten. Dann folgt ein Schritt, den wir in der vorherigen Variante noch nicht berücksichtigt hatten: Wir tragen für die Eigenschaft Tag <\/b>der aktuellen Registerseite den Primärschlüsselwert des Kunden ein, der auf dieser Registerseite angezeigt werden soll. Wozu wir diesen benötigen, erfahren Sie weiter unten. Danach stellen wir die Bezeichnung auf den Wert des Feldes Firma<\/b> für den auf dieser Registerseite darzustellenden Kunden ein, den wir per DLookup <\/b>aus der Tabelle tblKunden <\/b>ermitteln.<\/p>\n Listing 4: Laden der Einträge beim öffnen des Formulars<\/span><\/b><\/p>\n Erst dann erhöhen wir intGefuellt <\/b>um den Wert 1 <\/b>und stellen anschließend die Datenherkunft des Unterformulars dieser Registerseite auf die entsprechende SELECT<\/b>-Abfrage ein. intGefuellt <\/b>liefert dabei den Index für den Namen des Unterformular-Steuerelements (zum Beispiel sfm01<\/b>). Dies erledigt die Schleife nun für alle Datensätze des Recordsets. Sollte dieses weniger als zehn Datensätze enthalten, blendet die folgende If…Then<\/b>-Schleife noch die nicht genutzten Registerseiten aus.<\/p>\n Letzte Kunden zurücksetzen<\/b><\/p>\n Bisher haben wir noch keine Möglichkeit vorgesehen, wie der Benutzer die zuletzt angezeigten Kunden löschen kann, um wieder ein leeres Registersteuerelement zu erhalten. Dies erledigen wir mit einer neuen Schaltfläche oben im Formular (s. Bild 10).<\/p>\n Bild 10: Schaltfläche zum Leeren des Registersteuerelements<\/span><\/b><\/p>\n Die beim Anklicken dieser Schaltfläche ausgelöste Prozedur finden Sie in Listing 5. Die Prozedur löscht zunächst alle Datensätze aus der Tabelle tblLetzteKunden<\/b>. Dann durchläuft sie in einer For…Next<\/b>-Schleife alle Registerseiten des Registersteuerelements. Dabei stellt sie die Eigenschaft Visible <\/b>der Registerseiten auf den Wert False <\/b>ein und blendet diese somit aus. Außerdem stellt sie die Eigenschaft Tag <\/b>auf eine leere Zeichenkette ein und leert die Eigenschaft RecordSource <\/b>der Unterformulare auf den Registerseiten.<\/p>\n Listing 5: Leeren der Registerseiten<\/span><\/b><\/p>\n Anzeigen eines neuen Kunden<\/b><\/p>\n Die Prozedur, die per Doppelklick einen neuen Kundendatensatz auf der ersten Registerseite abbilden und alle bereits vorhandenen Kunden nach rechts verschieben soll, haben wir komplett überarbeitet. Die neue Version der durch das Ereignis Beim Doppelklicken<\/b> ausgelösten Ereignisprozedur sieht nun wie in Listing 6 aus.<\/p>\n Listing 6: öffnen eines neuen Elements auf der ersten Registerseite<\/span><\/b><\/p>\n Die Prozedur stellt zu Beginn die Eigenschaft Painting <\/b>des Formulars auf False <\/b>ein und deaktiviert so temporär das Neuzeichnen des Formulars. Dies erspart uns das sonst auftretende Flackern beim Ein- und Ausblenden und Verschieben von Elementen. Dann speichert sie den Primärschlüsselwert des im Listenfeld angeklickten Kunden in der Variablen lngKundeID<\/b>.<\/p>\n Dann folgen zwei Schritte, die Sie bereits aus der ersten Version der Prozedur kennen: Das Löschen des Datensatzes aus der Tabelle tblLetzterKunde<\/b>, dessen Feld LetzterKunde <\/b>mit dem Wert aus lngKundeID <\/b>übereinstimmt, sowie das Neuanlegen dieses Datensatzes. Dann öffnet die Prozedur wiederum ein Recordset auf Basis der zuletzt angelegten zehn Datensätze in der Tabelle tblLetzteKunden<\/b>. Dieses ist diesmal allerdings nicht dazu vorgesehen, alle Datensätze zu durchlaufen und dabei die Registerseiten entsprechend zu bestücken. Wir wollen damit lediglich die Anzahl der maximal zehn zuletzt angelegten Datensätze ermitteln und in der Variablen intAnzahlKunden <\/b>speichern.<\/p>\n Diesen Wert benötigen wir zuerst in einer For…Next<\/b>-Schleife über die Werte von 0 <\/b>bis zur Anzahl der Datensätze minus eins. Innerhalb der Schleife prüft die Prozedur in einer If…Then<\/b>-Bedingung, ob die Tag<\/b>-Eigenschaft der Registerseite mit dem Wert der Laufvariablen i <\/b>als Index mit dem in lngKundeID <\/b>gespeicherten Wert übereinstimmt – sprich: ob die aktuelle Registerseite zufällig bereits den Kunden anzeigt, den der Benutzer gerade im Listenfeld doppelt angeklickt hat.<\/p>\n Sie erinnern sich: Den Primärschlüsselwert des jeweils im Unterformular einer Registerseite angezeigten Kunden hatten wir ja in der Tag<\/b>-Eigenschaft der entsprechenden Registerseite gespeichert.<\/p>\n In diesem Fall stellen wir die Boolean<\/b>-Variable bolEnthalten <\/b>auf den Wert True <\/b>ein und stellen die Eigenschaft PageIndex <\/b>der Registerseite auf den Wert 0 <\/b>ein. Das heißt, dass wir diese Registerseite ganz nach links verschieben.<\/p>\n Schließlich machen wir, unabhängig davon, ob die Seite den aktuell angeklickten Kunden anzeigt, die Seite mit Visible = True <\/b>sichtbar. Auf diese Weise verfährt die Prozedur mit der dem Wert der Variablen intAnzahlKunden <\/b>entsprechenden Menge von Registerseiten.<\/p>\n Danach kümmert sie sich in einer weiteren Schleife um die übrigen Registerseiten – also um diejenigen Seiten, in denen keine Kundendaten angezeigt werden sollen. Dies geschieht allerdings nur, wenn intAnzahlKunden <\/b>kleiner als zehn ist. In dem Fall stellt die Prozedur die Visible<\/b>-Eigenschaften der hinteren Registerseiten auf den Wert False <\/b>ein und blendet diese damit aus.<\/p>\n Sollte der im Listenfeld angeklickte Kunde noch nicht auf einer der Registerseiten abgebildet worden sein, kommt die folgende If…Then<\/b>-Bedingung zum Tragen: Hat bolEnthalten <\/b>den Wert False <\/b>und ist die Anzahl der Kunden aus intAnzahlKunden <\/b>größer als eins, verschiebt die Prozedur zunächst alle gefüllten und sichtbaren Registerseiten um eine Position nach rechts, indem sie eine nicht gefüllte Registerseite nach links vorn holt.<\/p>\n Dazu stellt es die Eigenschaft PageIndex <\/b>der Registerseite, deren Index der Anzahl der Kunden minus eins entspricht, auf den Wert 0 <\/b>ein. Außerdem wird diese Seite über die Visible<\/b>-Eigenschaft eingeblendet.<\/p>\n Nachdem die Sortierung der Registerseiten abgeschlossen ist, soll die Registerseite ganz links angezeigt werden, was wir durch das Einstellen der Value<\/b>-Eigenschaft auf den Wert 0 <\/b>erreichen (die Value<\/b>-Eigenschaft ist die Standard-eigenschaft einer Registerseite, daher kann man diese auch weglassen).<\/p>\n Fehlt noch das Füllen des Unterformulars der nun nach vorne links geholten Registerseite. Den Namen des enthaltenen Unterformulars müssen wir erst noch ermitteln, denn nach dem wiederholten Aufrufen einiger Kundendatensätze gerät die Reihenfolge der Unterformulare auf den Registerseiten ordentlich durcheinander.<\/p>\n Also ermittelt die Prozedur über die Name<\/b>-Eigenschaft des ersten Steuerelements der ersten Registerseite den Namen des Unterformular-Steuerelements und speichert diesen in der Variablen strSubform<\/b>. Dann stellt sie die Beschriftung der Registerseite auf den Namen des Feldes Firma <\/b>des angezeigten Datensatzes ein.<\/p>\n Schließlich folgt die Zuordnung der passenden Datenherkunft über die Eigenschaft RecordSource des Unterformular-Steuerelements, das wir dank der Kenntnis des Namens des Unterformular-Steuerelements nun leicht referenzieren können.<\/p>\n Damit sind wir fast fertig – wir müssen nur noch die Eigenschaft Painting <\/b>wieder auf den Wert True <\/b>einstellen. Sollten Sie diese Anweisung vergessen oder tritt in der Prozedur ein Fehler auf, woraufhin diese abgebrochen wird, friert das Formular ein – Sie können es dann nicht mehr bedienen oder über das Formular selbst schließen. Sie müssen es dann beispielsweise über den Navigationsbereich im Entwurf öffnen und können es erst dann schließen.<\/p>\n Zusammenfassung und Ausblick<\/b><\/p>\n Die Lösung dieses Beitrags liefert eine einfache Möglichkeit, die zuletzt aufgerufenen Kunden schnell einzusehen.<\/p>\n Im ersten Ansatz zeigen wir, zu welchen performancetechnischen Problemen es kommen kann, wenn man den Fokus bei der Programmierung lediglich auf die Erfüllung der geplanten Funktion legt.<\/p>\n Später optimieren wir diese Lösung dann durch einige Tricks, was gute Kenntnis der Möglichkeiten von Registersteuerelement und von Unterformularen voraussetzt.<\/p>\n<\/p>\n Enthaltene Beispieldateien:<\/p>\n RegisterkartenFuerVerschiedeneDatensaetze.mdb<\/p>\n![\"Das](\"..\/fileadmin\/_temp_\/2015_01\/pic_967_001.png\")
<\/p>\n![\"Das](\"..\/fileadmin\/_temp_\/2015_01\/pic_967_002.png\")
<\/p>\nPrivate Sub <\/span>txtSuche_Change()\r\n Dim <\/span>strSuche As String<\/span>\r\n Dim <\/span>strSQL As String<\/span>\r\n strSuche = txtSuche.Text\r\n strSQL = \"SELECT * FROM tblKunden WHERE KundenCode Like ''*\" & strSuche _\r\n & \"*'' OR Firma LIKE ''*\" & strSuche _\r\n & \"*'' OR Kontaktperson LIKE ''*\" & strSuche & \"*''\"\r\n Me!lstKunden.RowSource = strSQL\r\nEnd Sub<\/span><\/pre>\n![\"Die](\"..\/fileadmin\/_temp_\/2015_01\/pic_967_003.png\")
<\/p>\n![\"Hinzufügen](\"..\/fileadmin\/_temp_\/2015_01\/pic_967_005.png\")
<\/p>\n![\"Der](\"..\/fileadmin\/_temp_\/2015_01\/pic_967_004.png\")
<\/p>\nPrivate Sub <\/span>lstKunden_DblClick(Cancel As Integer<\/span>)\r\n Me!regKunden.Pages(0).Caption = Me!lstKunden.Column(2)\r\n With<\/span> Me!sfm01\r\n .SourceObject = \"sfmKunden\"\r\n .Form.RecordSource = \"SELECT * FROM tblKunden WHERE KundeID = \" & Me!lstKunden\r\n End With<\/span>\r\nEnd Sub<\/span><\/pre>\n![\"Anzeige](\"..\/fileadmin\/_temp_\/2015_01\/pic_967_006.png\")
<\/p>\n![\"Tabelle](\"..\/fileadmin\/_temp_\/2015_01\/pic_967_007.png\")
<\/p>\n![\"Einrichten](\"..\/fileadmin\/_temp_\/2015_01\/pic_967_008.png\")
<\/p>\nPrivate Sub <\/span>lstKunden_DblClick(Cancel As Integer<\/span>)\r\n Dim <\/span>lngKundeID As Long<\/span>\r\n Dim <\/span>db As <\/span>DAO.Database\r\n Dim <\/span>rstLetzteKunden As <\/span>DAO.Recordset\r\n Dim <\/span>i As Integer<\/span>\r\n Dim <\/span>intGefuellt As Integer<\/span>\r\n Set<\/span> db = CurrentDb\r\n lngKundeID = Me!lstKunden\r\n db.Execute \"DELETE FROM tblLetzteKunden WHERE LetzterKunde = \" & lngKundeID, _\r\n dbFailOnError\r\n db.Execute \"INSERT INTO tblLetzteKunden(LetzterKunde) VALUES(\" & lngKundeID & \")\", _\r\n dbFailOnError\r\n Set<\/span> rstLetzteKunden = db.OpenRecordset(\"SELECT TOP 10 LetzterKunde " _\r\n "FROM tblLetzteKunden ORDER BY LetzterKundeID DESC\", _\r\n dbOpenDynaset)\r\n Do While<\/span> Not<\/span> rstLetzteKunden.EOF\r\n Me!regKunden.Pages(intGefuellt).Visible = True<\/span>\r\n Me!regKunden.Pages(intGefuellt).Caption = DLookup(\"Firma\", \"tblKunden\", _\r\n \"KundeID = \" & rstLetzteKunden!LetzterKunde)\r\n intGefuellt = intGefuellt + 1\r\n With<\/span> Me(\"sfm\" & Format(intGefuellt, \"00\"))\r\n .SourceObject = \"sfmKunden\"\r\n .Form.RecordSource = \"SELECT * FROM tblKunden WHERE KundeID = \" _\r\n & rstLetzteKunden!LetzterKunde\r\n End With<\/span>\r\n rstLetzteKunden.MoveNext<\/span>\r\n Loop<\/span>\r\n For i = intGefuellt To 9\r\n Me!regKunden.Pages(i).Visible = False<\/span>\r\n With<\/span> Me(\"sfm\" & Format(i + 1, \"00\"))\r\n .SourceObject = \"\"\r\n End With<\/span>\r\n Next<\/span> i\r\nEnd Sub<\/span><\/pre>\n.SourceObject = \"sfmKunden\"<\/pre>\n
With<\/span> Me(\"sfm\" & Format(i + 1, \"00\"))\r\n .SourceObject = \"\"\r\nEnd With<\/span><\/pre>\nMe!regKunden.Pages(0).Controls(0).Name<\/pre>\n
Private Sub <\/span>Form_Load()\r\n Dim <\/span>db As <\/span>DAO.Database\r\n Dim <\/span>rstLetzteKunden As <\/span>DAO.Recordset\r\n Dim <\/span>i As Integer<\/span>\r\n Dim <\/span>intGefuellt As Integer<\/span>\r\n Set<\/span> db = CurrentDb\r\n Set<\/span> rstLetzteKunden = db.OpenRecordset( _\r\n \"SELECT TOP 10 LetzterKunde FROM tblLetzteKunden ORDER BY LetzterKundeID DESC\", _\r\n dbOpenDynaset)\r\n Do While<\/span> Not<\/span> rstLetzteKunden.EOF\r\n Me!regKunden.Pages(intGefuellt).Visible = True<\/span>\r\n Me!regKunden.Pages(intGefuellt).Tag = rstLetzteKunden!LetzterKunde\r\n Me!regKunden.Pages(intGefuellt).Caption = DLookup(\"Firma\", \"tblKunden\", _\r\n \"KundeID = \" & rstLetzteKunden!LetzterKunde)\r\n intGefuellt = intGefuellt + 1\r\n With<\/span> Me(\"sfm\" & Format(intGefuellt, \"00\"))\r\n .Form.RecordSource = \"SELECT * FROM tblKunden WHERE KundeID = \" _\r\n & rstLetzteKunden!LetzterKunde\r\n End With<\/span>\r\n rstLetzteKunden.MoveNext<\/span>\r\n Loop<\/span>\r\n For i = intGefuellt To 9\r\n Me!regKunden.Pages(i).Visible = False<\/span>\r\n Next<\/span> i\r\nEnd Sub<\/span><\/pre>\n![\"Schaltfläche](\"..\/fileadmin\/_temp_\/2015_01\/pic_967_010.png\")
<\/p>\nPrivate Sub <\/span>cmdRegisterLeeren_Click()\r\n Dim <\/span>db As <\/span>DAO.Database\r\n Dim <\/span>i As Integer<\/span>\r\n Set<\/span> db = CurrentDb\r\n db.Execute \"DELETE FROM tblLetzteKunden\", dbFailOnError\r\n For i = 9 To 0 Step -1\r\n Me!regKunden.Pages(i).Visible = False<\/span>\r\n Me!regKunden.Pages(i).Tag = \"\"\r\n Me!regKunden.Pages(i).Controls(0).Form.RecordSource = \"\"\r\n Next<\/span> i\r\n Set<\/span> db = Nothing\r\nEnd Sub<\/span><\/pre>\nPrivate Sub <\/span>lstKunden_DblClick(Cancel As Integer<\/span>)\r\n Dim <\/span>lngKundeID As Long<\/span>\r\n Dim <\/span>db As <\/span>DAO.Database\r\n Dim <\/span>rstLetzteKunden As <\/span>DAO.Recordset\r\n Dim <\/span>i As Integer<\/span>\r\n Dim <\/span>strSubform As String<\/span>\r\n Dim <\/span>bolEnthalten As Boolean<\/span>\r\n Set<\/span> db = CurrentDb\r\n Me.Painting = False<\/span>\r\n lngKundeID = Me!lstKunden\r\n db.Execute \"DELETE FROM tblLetzteKunden WHERE LetzterKunde = \" _\r\n & lngKundeID, dbFailOnError\r\n db.Execute \"INSERT INTO tblLetzteKunden(LetzterKunde) VALUES(\" _\r\n & lngKundeID & \")\", dbFailOnError\r\n Set<\/span> rstLetzteKunden = db.OpenRecordset( _\r\n \"SELECT TOP 10 LetzterKunde FROM tblLetzteKunden ORDER BY LetzterKundeID DESC\", _\r\n dbOpenDynaset)\r\n rstLetzteKunden.MoveLast\r\n For i = 0 To rstLetzteKunden.RecordCount - 1\r\n If <\/span>Me!regKunden.Pages(i).Tag = lngKundeID Then<\/span>\r\n bolEnthalten = True<\/span>\r\n Me!regKunden.Pages(i).PageIndex = 0\r\n End If<\/span>\r\n Me!regKunden.Pages(i).Visible = True<\/span>\r\n Next<\/span> i\r\n For i = rstLetzteKunden.RecordCount To 9\r\n Me!regKunden.Pages(i).Visible = False<\/span>\r\n Next<\/span> i\r\n If <\/span>Not<\/span> bolEnthalten And rstLetzteKunden.RecordCount > 1 Then<\/span>\r\n Me!regKunden.Pages(rstLetzteKunden.RecordCount - 1).PageIndex = 0\r\n Me!regKunden.Pages(rstLetzteKunden.RecordCount - 1).Visible = True<\/span>\r\n End If<\/span>\r\n Me!regKunden = 0\r\n strSubform = Me!regKunden.Pages(0).Controls(0).Name\r\n Me!regKunden.Pages(0).Caption = DLookup(\"Firma\", \"tblKunden\", \"KundeID = \" & lngKundeID)\r\n Me!regKunden.Pages(0).Controls(strSubform).Form.RecordSource = _\r\n \"SELECT * FROM tblKunden WHERE KundeID = \" & lngKundeID\r\n Me.Painting = True<\/span>\r\nEnd Sub<\/span><\/pre>\nDownloads zu diesem Beitrag<\/h2>\n