<\/p>\n
In Detailformularen zeigen Sie Datensätze an, bearbeiten oder betrachten diese und schließen dann das Formular oder wechseln zum nächsten Datensatz. In vielen Fällen möchten Sie aber dann vielleicht noch einmal zu einem der zuvor bearbeiteten Datensätze – und gegebenenfalls wieder zurück. Solch eine Funktion bietet Access nicht, dort können Sie über die Navigationsschaltflächen nur durch die Datensätze in der Reihenfolge der Datenherkunft springen. Wir statten in diesem Beitrag ein Formular mit einer Historie aus, wie Sie sie auch vom Internet-Browser kennen.<\/b><\/p>\n
Im Internet-Browser starten Sie beispielsweise mit einer Google-Suche, finden dann in der Ergebnisliste eine Seite und rufen diese dann auf. Dort fällt Ihnen ein weiterer Links ins Auge, den Sie sich anschauen. Sie entscheiden sich, dass Sie doch wieder zum vorherigen Link zurückwechseln möchten. Bringt dieser nicht das gewünschte Ergebnis, soll es wieder zurück zum Suchergebnis gehen, von wo Sie entweder den nächsten Treffer betrachten oder vielleicht sogar die Seite mit den folgenden Treffern aufrufen.<\/p>\n
Wie auch immer dies läuft: Die Vor- und Zurück-Tasten des Browsers nehmen Ihnen hier eine Menge Arbeit ab. Dabei bieten diese die folgenden Möglichkeiten:<\/p>\n
![\"Historie](\"..\/fileadmin\/_temp_\/2014_04\/pic_942_002.png\")
<\/p>\n
Bild 1: Historie im Internet-Explorer<\/span><\/b><\/p>\n Bild 2: Anzeige des Verlaufs<\/span><\/b><\/p>\n<\/ul>\n Das sind interessante Aussichten – vor allem, wenn man sich vorstellt, dies etwa auf ein Kunden-Formular zu übertragen und mal eben schnell die Kunden zu betrachten, die man zuletzt oder vor zwei Tagen bearbeitet hat.<\/p>\n Also wollen wir uns nun an die Umsetzung dieser nützlichen Funktion für ein Access-Formular machen.<\/p>\n Vorgaben<\/b><\/p>\n Zuvor müssen wir noch ein paar Definitionen treffen, die sich auf das Verhalten der Schaltflächen beziehen. Wenn Sie sich nur vorwärts durch die Kunden bewegen, ist es kein Problem – alle bisher besichtigten Kundendatensätze werden dann in der richtigen Reihenfolge in der Liste der zuvor betrachteten Kunden abgelegt.<\/p>\n Was aber geschieht, wenn ich mich vom aktuellen Datensatz zu dem zuvor betrachteten Datensatz bewege und dann einen anderen Datensatz aufrufe als den, von dem ich gerade komme Sprich: Ich schaue mir erst Datensatz A an, dann Datensatz B, gehe zu Datensatz A zurück und rufe dann Datensatz C auf. Im Browser wird dies so gelöst, dass Datensatz B in diesem Fall aus der Reihenfolge verschwindet. Im Verlauf werden alle Seiten angezeigt. Dies wollen wir auch so umsetzen.<\/p>\n Ausgangsformular<\/b><\/p>\n Wir beginnen mit einem Formular, das wie in Bild 3 aussieht. Es verwendet die Tabelle tblKunden<\/b> der Beispieldatenbank als Datenherkunft und zeigt alle Felder im Detailbereich an. Im Formularkopf haben wir ein Kombinationsfeld eingebaut, mit dem der Benutzer direkt zu jedem beliebigen Datensatz springen kann.<\/p>\n Bild 3: Entwurf des Beispielformulars<\/span><\/b><\/p>\n Das Kombinationsfeld heißt cboAuswahl <\/b>und soll immer beim Anzeigen eines Datensatzes direkt mit dem Datensatz gefüllt werden, der auch im Formular erscheint. Dazu müssen wir zunächst die Datensatzherkunft des Kombinationsfeldes auf die folgende Abfrage einstellen:<\/p>\n Damit das Kombinationsfeld nur den Inhalt des Feldes Firma <\/b>anzeigt, aber nicht den des Feldes KundeID<\/b>, stellen Sie die Eigenschaften Spaltenanzahl <\/b>auf 2 <\/b>und Spaltenbreiten <\/b>auf 0cm <\/b>ein. Um das Kombinationsfeld beim Auswählen eines Datensatzes über die übrigen Elemente des Formulars wie etwa die Navigationsschaltflächen mit dem Da-tensatz des Formulars zu synchronisieren, legen Sie die folgende Ereignispro-zedur an:<\/p>\n Diese wird durch das Ereignis Beim Anzeigen <\/b>des Formulars ausgelöst.<\/p>\n Nun müssen wir noch dafür sorgen, dass das Formular auch nach der Auswahl eines Eintrags im Kombinationsfeld gleich den passenden Datensatz anzeigt. Dies erledigt die folgende Ereignisprozedur, die durch das Ereignis Nach Aktualisierung <\/b>des Kombinationsfeldes ausgelöst wird:<\/p>\n Vor-und-Zurück-Schaltfläche<\/b><\/p>\n Wenn dies alles funktioniert, können wir uns der Erweiterung zuwenden. Dazu fügen Sie neben dem Kombinationsfeld zwei Schaltflächen hinzu, die Sie mit dem Kleiner- und dem Größer-Zeichen als Beschriftung ausstatten. Die Schaltflächen sollen cmdVor <\/b>und cmdZurueck <\/b>heißen und jeweils eine eigene Ereignisprozedur beim Anklicken auslösen.<\/p>\n Mit den Schaltflächen sieht der Formularkopf nun wie in Bild 4 aus.<\/p>\n Bild 4: Kombinationsfeld zur Auswahl von Kunden-Datensätzen. Rechts die Schaltflächen zum Vor- und Zurückblättern<\/span><\/b><\/p>\n Verlauf speichern<\/b><\/p>\n Bevor wir uns an die Programmierung der Funktion für die Schaltflächen begeben, müssen wir erst einmal eine Möglichkeit schaffen, die zuletzt besuchten Datensätze zu speichern. Dies wird ohne Zweifel eine Tabelle sein, da die Daten ja auch nach dem Schließen und erneutem öffnen zur Verfügung stehen sollen. Aber welche Felder benötigen wir in dieser Tabelle Die erste Frage, die sich stellt, ist die nach dem Primärschlüsselfeld.<\/p>\n Benötigen wir ein eigenes Primärschlüsselfeld, wenn wir doch wahrscheinlich in einem Feld der Tabelle den Wert des Primärschlüsselfeldes der Tabelle tblKunden<\/b> speichern – also der Tabelle, für die wir die Zugriffe speichern möchten Man könnte es tun, wenn man dieses Primärschlüsselfeld zur Sortierung verwenden möchte.<\/p>\n Was aber ist, wenn man erst den Kunden A aufruft, dann Kunde B und Kunde C und schließlich wieder zu Kunde A zurückspringt Kunde A kann dann, wenn der Verlauf tatsächlich in chronologischer Reihenfolge dargestellt werden soll, nicht mehr über den Primärschlüsselwert an die richtige Position gebracht werden, da diese ja nicht geändert werden kann.<\/p>\n Also vergeben wir keinen eigenen Autowert-Primärschlüssel für die Tabelle, sondern übernehmen einfach den Primärschlüssel aus der Kundentabelle als eindeutiges Merkmal für die angezeigten Datensätze. Diesen benötigen wir dann später auch, um einen der Kundendatensätze aus der Verlaufsliste heraus aufrufen zu können.<\/p>\n Wie aber sortieren wir die Datensätze dann in chronologischer Reihenfolge, und wie bringen wir diese in Ordnung, wenn der Benutzer einen bereits im Verlauf befindlichen Kunden nochmals aufruft Zu diesem Zweck fügen wir der Tabelle ein Feld namens Zugriffszeit <\/b>hinzu. Diese nimmt Datum und Zeit des letzten Zugriffs auf diesen Datensatz auf.<\/p>\n Auf diese Weise brauchen wir, wenn der Benutzer einen bereits in der Verlaufstabelle befindlichen Datensatz erneut aufruft, auch nur eine kleine änderung an diesem Datensatz vorzunehmen – nämlich den Wert im Feld Zugriffszeit zu aktualisieren.<\/p>\n Wenn wir die Anzeige der Verlaufsliste dann absteigend nach dem Inhalt des Feldes Zugriffszeit sortieren, liefert diese immer die zuletzt verwendeten Datensätze zuerst.<\/p>\n Die Tabelle zum Speichern des Verlaufs soll tblVerlauf<\/b> heißen und nimmt aktuell die Felder auf, die auch in der Entwurfsansicht in Bild 5 zu erkennen sind.<\/p>\n Bild 5: Diese Tabelle speichert den Verlauf der zuletzt aufgerufenen Kunden.<\/span><\/b><\/p>\n Noch nicht gesprochen haben wir über das letzte Feld dieser Tabelle namens PopuplisteID<\/b>. Wir wollen ja wie im Internet Explorer sowohl eine Verlaufsliste mit der kompletten Historie der zuletzt aufgerufenen Kunden darstellen, aber auch Ziele für die beiden Schaltflächen zum Anspringen des vorherigen und des nächsten Datensatzes speichern und diese auch in einem Popup-Listenfeld anzeigen. Letztere sollen allerdings nach dem Schließen des Formulars gelöscht und nach dem erneuten öffnen und Auswählen von Datensätzen wieder gefüllt werden.<\/p>\n Für diese Liste wollen wir jeweils maximal sieben Einträge speichern. Wenn der Benutzer Kunde 1 auswählt, erhält Kunde 1 in diesem Feld den Wert 0<\/b>. Wählt der Benutzer dann Kunde 2 aus, erhält Kunde 1 den Wert -1 <\/b>und Kunde 2 den Wert 0<\/b>. Folgt dann Kunde 3, erhält Kunde 1 den Wert -2<\/b>, Kunde 2 erhält den Wert -1 <\/b>und Kunde 3 den Wert 0<\/b>. Springt der Benutzer dann zu Kunde 2 <\/b>zurück, erhält Kunde 1 den Wert -1<\/b>, Kunde 2 den Wert 0 <\/b>und Kunde 3 den Wert 1 <\/b>im Feld PopuplisteID<\/b>.<\/p>\n Der aktuelle Kunde erhält also immer den Wert 0<\/b>, die Liste wird immer in Richtung der positiven Zahlen erweitert. Was aber geschieht, wenn der Benutzer nun vom aktuellen Kunden (Nummer 0<\/b>) aus zum vorherigen Kunden springen kann (-1<\/b>) und zum folgenden (1<\/b>), aber einen neuen Kunden auswählt<\/p>\n In diesem Fall wird der Pfad in Richtung positiver Zahlen gelöscht, der neue Kunde mit der Zahl 0 <\/b>und die übrigen mit -1<\/b>, -2 <\/b>und -3 <\/b>versehen.<\/p>\n Programmierung des Verlaufs<\/b><\/p>\n Theoretisch hört sich das alles recht einfach an – in der Praxis ist es allerdings etwas komplizierter als erwartet.<\/p>\n Vor allem solche Details wie das Einblenden der Popupliste nach längerem Drücken der beiden Schaltflächen cmdVorheriger <\/b>und cmdNaechster<\/b> sind recht aufwendig zu programmieren.<\/p>\n Die Popupliste<\/b><\/p>\n Unter den Schaltflächen cmdVorheriger <\/b>und cmdNaechster <\/b>müssen wir noch die Liste unterbringen, die beim längeren Drücken einer der beiden Schaltflächen eingeblendet wird. Dies erledigen wir mit einem Listenfeld namens lstPopupliste<\/b>, das wir wie in Bild 6 im Formular positionieren.<\/p>\n Bild 6: Die Popupliste realisieren wir in Form eines Listenfeldes, das zunächst unsichtbar ist und nur bei Bedarf eingeblendet wird.<\/span><\/b><\/p>\n Für dieses Listenfeld legen wir eine Datensatzherkunft namens qryPopupliste <\/b>an.<\/p>\n Diese sieht im Entwurf wie in Bild 7 aus und liefert alle Datensätze der Tabelle tblVerlauf<\/b>, deren Feld PopuplisteID <\/b>nicht leer ist – und zwar in absteigender Reihenfolge nach diesem Feld sortiert.<\/p>\n Bild 7: Dies ist die Datensatzherkunft für die Popupliste.<\/span><\/b><\/p>\n Popupliste beim Laden zurücksetzen<\/b><\/p>\n Wenn das Formular geöffnet wird, soll eine neue Historie der zuletzt verwendeten Datensätze geschaffen werden. Dies betrifft nicht den eigentlichen Verlauf in zeitlicher Abfolge – dieser soll immer erhalten bleiben.<\/p>\n Für die Auswahl eines der seit dem öffnen des Formulars angezeigten Datensätze ist aber auch nur der Inhalt des Feldes PopupListeID <\/b>der Tabelle tblVerlauf <\/b>verantwortlich, sodass dieses Feld einfach nur beim Laden des Formulars geleert werden soll.<\/p>\n Dies erledigt die Ereignisprozedur Form_Load<\/b>, die durch das Ereignis Beim Laden <\/b>ausgelöst wird:<\/p>\n Speichern des aktuellen Datensatzes<\/b><\/p>\n Die erste Aufgabe lautet, überhaupt den aktuellen Datensatz in die Tabelle tblVerlauf<\/b> einzutragen beziehungsweise die Position für die Anzeige in der Popup-liste der zuletzt verwendeten Datensätze zu speichern. Wann soll dieser überhaupt gespeichert werden Direkt nach dem Anzeigen. Dies erledigen wir am einfachsten mit einer Ereignisprozedur, die durch das Ereignis Beim Anzeigen <\/b>des Formulars ausgelöst wird.<\/p>\n Diese Prozedur sieht wie in Listing 1 aus und stellt zunächst das Kombinationsfeld cboAuswahl <\/b>auf den Datensatz ein, der auch im Formular angezeigt wird. Dann ruft sie eine Prozedur namens VerlaufSpeichern <\/b>auf, welche den Primärschlüsselwert und die Bezeichnung des aktuellen Datensatzes, hier den Wert des Feldes Firma<\/b>, als Parameter erwartet. Diese Prozedur finden Sie in Listing 2: Sie legt einen neuen Datensatz in der Tabelle tblVerlauf <\/b>an und trägt dabei den Primärschlüsselwert des Datensatzes (aus dem Parameter lngPKID<\/b>), den Titel für die Anzeige im Popup-Listenfeld (aus strTitel<\/b>) sowie Zeit und Datum ein.<\/p>\n <\/p>\n Listing 1: Speichern des soeben aufgerufenen Datensatzes in der Tabelle tblVerlauf<\/span><\/b><\/p>\n Sollte bereits ein Datensatz für diesen Kunden vorhanden sein, löst der Versuch, diesen erneut anzulegen, den Fehler 3022 <\/b>aus. Diesen behandeln wir entsprechend, indem wir einfach dem bereits vorhandenen Datensatz den aktuelle Wert für Datum und Zeit zuweisen. Damit wäre der aktuell ausgewählte Datensatz also zumindest schon in der Tabelle tblVerlauf <\/b>gespeichert.<\/p>\n Die aufrufende Prozedur Form_Current <\/b>blendet nun das Listenfeld lstPopupliste <\/b>aus, da diese ja gegebenenfalls durch vorheriges Drücken einer der beiden Schaltflächen cmdVorheriger <\/b>oder cmdNaechster <\/b>eingeblendet worden sein könnte. Dann ruft sie eine weitere Prozedur auf, die sich um das aktualisieren des Feldes PopuplisteID <\/b>in der Tabelle tblVerlauf <\/b>kümmert – mehr dazu weiter unten.<\/p>\n Schließlich sollen auch noch, wie beim Internet Explorer, die beiden Schaltflächen cmdVorheriger <\/b>und cmdNaechster <\/b>aktiviert oder deaktiviert werden – je nachdem, ob in der Popupliste bereits Einträge stehen, die seit dem öffnen des Formulars vor oder nach dem aktuellen Datensatz angezeigt wurden. Dazu prüft die Prozedur per DLookup<\/b>-Funktion, ob die Tabelle tblVerlauf <\/b>mindestens einen Datensatz enthält, dessen Wert im Feld PopuplisteID <\/b>größer als 0 <\/b>ist. In diesem Fall blendet sie die Schaltfläche cmdNaechster <\/b>ein, anderenfalls wird die Schaltfläche ausgeblendet. Gleiches geschieht wenige Zeilen danach mit der Schaltfläche cmdVorheriger<\/b>.<\/p>\n Popup-Liste aktualisieren<\/b><\/p>\n Die Prozedur PopuplisteAktualisieren <\/b>wird jeweils beim Anzeigen eines Datensatzes im Formular aufgerufen (s. Listing 3). Sie ermittelt zunächst die Anzahl der Einträge, die im Listenfeld lstPopupliste<\/b> angezeigt werden sollen. Dies sind alle Datensätze der Tabelle tblVerlauf<\/b>, für die im Feld PopuplisteID<\/b> zuvor ein Zahlenwert hinterlegt wurde. Wenn das Formular soeben geöffnet wurde, ist dieser Wert 0<\/b> – dafür hat die weiter oben beschriebene Prozedur Form_Load <\/b>gesorgt, die das Feld PopuplisteID <\/b>für alle Datensätze geleert hat.<\/p>\n Listing 3: Aktualisieren der Werte für das Feld PopuplisteID der Tabelle tblVerlauf<\/span><\/b><\/p>\n Wenn die Anzahl der Einträge also 0 <\/b>ist, wie es direkt nach dem öffnen des Formulars der Fall ist, führt die Prozedur gleich den If<\/b>-Teil der If…Then<\/b>-Bedingung der Prozedur aus. Die einzige dort enthaltene Anweisung stellt den Wert des Feldes PopuplisteID <\/b>für den aktuell angezeigten Datensatz auf den Wert 0 <\/b>ein. 0 <\/b>steht ja, wie weiter oben beschrieben, für den aktuell geöffneten Datensatz. In diesem Fall ist die Prozedur damit beendet. Die aufrufende Prozedur Form_Current <\/b>prüft nun noch, ob eine der beiden Schaltflächen cmdVorheriger <\/b>oder cmdNaechster <\/b>aktiviert wird werden muss, was aber nicht der Fall ist.<\/p>\n Weiteren Datensatz ansehen<\/b><\/p>\n Schauen wir uns an, was in der Prozedur PopuplisteAktualisieren <\/b>geschieht, wenn der Benutzer nun einen weiteren Datensatz betrachtet. Dies löst den Else<\/b>-Teil der If…Then<\/b>-Bedingung aus, denn nun gibt es ja bereits einen Datensatz, dessen Feld PopuplisteID <\/b>gefüllt ist (hier mit dem Wert 0<\/b>). An dieser Stelle wissen wir noch nicht, dass bislang nur ein einziger Datensatz zur Popupliste hinzugefügt wurde und dass der nun ausgewählte Datensatz noch nicht dazugehört. Daher prüft die Prozedur dies mit einem weiteren Aufruf der DLookup<\/b>-Funktion, der diesmal untersucht, ob das Feld PopuplisteID <\/b>für den aktuell im Formular angezeigten Datensatz bereits einen Wert enthält. Ist dies nicht der Fall, liefert DLook-up <\/b>den Wert Null<\/b>, was durch die umschließende Nz<\/b>-Funktion in den Wert 99 <\/b>umgewandelt und in der Variablen lngPositionDesAktuellenEintragsInPopupliste <\/b>gespeichert wird.<\/p>\n Die nun folgende If…Then<\/b>-Bedingung prüft, ob lngPositionDesAktuellenEintragsInPopupliste <\/b>den Wert 99 <\/b>aufweist. In diesem Fall leert die Prozedur das Feld PopuplisteID <\/b>für alle Datensätze, in denen dieses Feld einen Wert größer als 0 <\/b>aufweist. Dies ist etwa für den Fall, dass der Benutzer Kunde 1, Kunde 2 und Kunde 3 aufruft, dann zu Kunde 2 zurückspringt und Kunde 4 aufruft – in diesem Fall soll Kunde 3 aus der Popupliste entfernt werden.<\/p>\n Anschließend ändert die Prozedur den Wert des Feldes PopuplisteID <\/b>für alle Datensätze, in denen dieses Feld nicht leer ist, indem es den Wert 1 <\/b>subtrahiert. Für unseren zuvor angezeigten Datensatz ändert sich der Wert in diesem Feld also von 0 <\/b>auf -1<\/b>. Dann stellt es den entsprechenden Wert für den aktuell angezeigten Datensatz in der Tabelle tblVerlauf <\/b>auf den Wert 0 <\/b>ein. Der aktuelle Stand also: Ein Eintrag mit dem Wert 0<\/b>, einer mit -1<\/b>. Schauen wir uns auf diese Weise noch die zwei weiteren Einträge an, weisen die vier Einträge die Werte 0<\/b>, -1<\/b>, -2 <\/b>und -3 <\/b>im Feld PopupListeID <\/b>der Tabelle tblVerlauf <\/b>auf. Die Abfrage qryVerlauf<\/b> zeigt diese Situation in Bild 8.<\/p>\n Bild 8: Vier Kunden mit dem Index für die Popup-Liste<\/span><\/b><\/p>\n Ausgehend davon soll nun einmal ein Datensatz ausgewählt werden, der bereits im Verlauf enthalten ist. Dabei spielt es keine Rolle, ob Sie diesen über das Kombinationsfeld cboAuswahl <\/b>auswählen oder über die Navigationsschaltflächen des Formulars (später kommen natürlich noch Prozeduren hinzu, mit denen Sie dies über die Schaltflächen cmdVorheriger <\/b>und cmdNaechster <\/b>beziehungsweise über das Listenfeld lstPopupliste <\/b>erledigen können).<\/p>\n Wählen wir also nun beispielsweise den Datensatz aus, bei dem der Wert -1 <\/b>im Feld PopuplisteID <\/b>steht. Wir springen an dieser Stelle also quasi einen Datensatz zurück.<\/p>\n Dies löst wieder die Prozedur Form_Current <\/b>aus, und diese startet die Prozedur PopuplisteAktualisieren<\/b>. Wir ermitteln wieder den Wert des Feldes PopuplisteID <\/b>des aktuellen Datensatzes und speichern diesen in der Variablen lngPositionDesAktuellenEintragsInPopupliste<\/b>. Da dieser Wert nun nicht mehr 99<\/b>, sondern -1 <\/b>beträgt, steuert die Prozedur in der inneren If…Then<\/b>-Bedingung nun nicht den If<\/b>-, sondern den Else<\/b>-Teil an.<\/p>\n Hier speichert die Prozedur den Wert von lngPositionDesAktuellenEintragsInPopupliste <\/b>in der Variablen intDifferenz<\/b>. intDifferenz <\/b>enthält also nun den Abstand des neu ausgewählten Datensatzes von dem zuletzt ausgewählten Datensatz. Dieser Wert wird benötigt, damit wir die Werte des Feldes Popup-listeID <\/b>so verschieben können, dass der aktuell ausgewählte Datensatz den Wert 0 <\/b>erhält und alle anderen entsprechend angepasst werden. Dies erledigen wir in einer einzigen UPDATE<\/b>-Anweisung, die für alle Datensätze, die überhaupt einen Wert im Feld PopuplisteID <\/b>eine Wert aufweisen, den in intDifferenz <\/b>gespeicherten Wert subtrahiert.<\/p>\n Das Ergebnis sieht nun wie in Bild 9 aus: Statt drei vorheriger Einträge gibt es nun zwei vorherige Einträge und einen folgenden Eintrag in der Tabelle.<\/p>\n Bild 9: Der Kunde mit PKID = 3 ist nun der aktuell angezeigt Kunde.<\/span><\/b><\/p>\n Nun gibt es noch eine Konstellation, die wir beachten müssen. Was geschieht nun, wenn der Benutzer einen Datensatz auswählt, der noch nicht über das Feld PopupListeID <\/b>als Eintrag der Popup-Liste markiert ist Der Plan ist, dass dieser Eintrag der neue aktuelle Eintrag wird. Die vom bisherigen aktuellen Eintrag aus als folgende Einträge markierten Datensätze sollen wegfallen, die übrigen werden entsprechend angepasst. Das Ergebnis soll wie in Bild 10 aussehen. Der Datensatz mit dem Wert 4 <\/b>im Feld PKID <\/b>fällt weg, der neue Datensatz mit der 14 <\/b>erhält den Wert 0 <\/b>im Feld PopuplisteID <\/b>und bei den übrigen wird der Wert 1 <\/b>vom Feld PopuplisteID <\/b>subtrahiert.<\/p>\n Bild 10: Der bisher als folgender Datensatz markierte Kunde wird aus der Liste entfernt, die übrigen rücken nach hinten.<\/span><\/b><\/p>\n Dieser Fall wird ebenfalls im ersten Teil der inneren If…Then<\/b>-Anweisung behandelt. lngPositionDesAktuellenEintragsInPopupliste <\/b>erhält hier den Wert 99<\/b>, da der Kunde ja noch nicht ausgewählt wurde. Die erste der drei UPDATE<\/b>-Anweisungen leert das Feld PopuplisteID <\/b>für alle Datensätze, bei denen der Wert dieses Feldes größer als 0 <\/b>ist. Die zweite stellt dieses Feld für den aktuellen Datensatz auf 0 <\/b>ein und zieht für alle übrigen Datensätze, deren Feld PopuplisteID <\/b>nicht leer ist, den Wert 1 <\/b>ab.<\/p>\n Vorherigen und nächsten Datensatz auswählen<\/b><\/p>\n Damit haben wir bereits alle Fälle abgedeckt und können uns nun um die Steuerelemente zum Ansteuern der als vorherige und nächste Datensätze markierten Kunden kümmern.<\/p>\n Dabei sind die Aktionen zum Auswählen des vorherigen und des nächsten Datensatzes sowie das Anzeigen der Liste der vorherigen und nächsten Datensätze eng miteinander verknüpft.<\/p>\n Der Hintergrund ist, dass Access kein Ereignis vorsieht, das reagiert, wenn man eine Schaltlfäche eine gewisse Zeit gedrückt hält. Genau dies ist aber das Ziel – wir wollen ja das Verhalten des Internet Explorers möglichst genau nachstellen. Dazu soll ein einfacher Mausklick etwa auf die Schaltfläche cmdVorheriger <\/b>den vorherigen Datensatz anzeigen. Ein längerer Klick hingegen soll das Listenfeld mit den zuletzt verwendeten Datensätzen einblenden (s. Bild 11).<\/p>\n Bild 11: Das Listenfeld zum Auswählen der vorherigen und der folgenden Datensätze in Aktion<\/span><\/b><\/p>\n Warum ist dies so kompliziert Man könnte doch die Ereigniseigenschaft Beim Klicken <\/b>nutzen, um direkt zum vorherigen oder folgenden zu springen und die Ereignisse Bei Maustaste ab <\/b>und Bei Maustaste auf <\/b>irgendwie nutzen, um das Listenfeld lstPopupliste <\/b>einzublenden. Grundsätzlich ist das eine gute Idee, scheitert aber an den Eigenschaften der Ereignisse.<\/p>\n Wenn wir eine der Schaltflächen anklicken und schnell wieder loslassen, soll also nur das Ereignis ausgelöst werden, das wir für die Ereignisprozedur Beim Klicken <\/b>hinterlegt haben. Erst, wenn wir die Schaltfläche länger gedrückt halten, soll das Listenfeld eingeblendet werden (dies wollen wir in der Prozedur programmieren, die durch Bei Maustaste ab <\/b>ausgelöst wird). Wenn wir die Maustaste dann loslassen (löst das Ereignis Bei Maustaste auf <\/b>aus), soll natürlich nichts weiter geschehen, denn das Ziel ist ja schon erreicht – das Listenfeld wurde eingeblendet.<\/p>\n Hier macht uns das Ereignis Beim Klicken <\/b>einen Strich durch die Rechnung, denn dieses wird natürlich immer beim Loslassen der Schaltfläche ausgelöst – also auch, wenn wir die Schaltfläche länger gedrückt gehalten haben, um das Listenfeld einzublenden.<\/p>\n Also lassen wir die Ereignisprozeduren weg, die durch das Ereignis Beim Klicken <\/b>ausgelöst werden, und verwenden lediglich die beiden Ereignisse Bei Maustaste ab <\/b>und Bei Maustaste auf<\/b>.<\/p>\n Bei Zeitgeber<\/b><\/p>\n Die nächste Frage ist, wie wir prüfen, wie lange der Benutzer bereits die entsprechende Schaltfläche gedrückt hält. Die erste Idee war, dazu den Zeitgeber des Formulars zu nutzen. Das klappt aber auch nicht, denn das Ereignis Bei Zeitgeber <\/b>wird nicht ausgelöst, solange der Benutzer eine Schaltfläche gedrückt hält. So sind wir dann bei der Prozedur gelandet, die Sie in Listing 4 finden.<\/p>\n Listing 4: Das Herunterdrücken der Schaltfläche zum Anzeigen des vorherigen Datensatzes löst diese Prozedur aus.<\/span><\/b><\/p>\n Diese stellt zuerst den Wert der Variablen bolVorheriger <\/b>auf den Wert True <\/b>ein. Diese Variable soll später auch noch von der Prozedur ausgelesen werden können, die durch das Ereignis Bei Maustaste auf <\/b>ausgelöst wird. Daher deklarieren wir diese wie folgt im allgemeinen Teil des Klassenmoduls Form_frmKunden <\/b>des Formulars:<\/p>\n Wo wir schon beim Deklarieren sind, legen wir auch gleich noch die entsprechende Variable für die Schaltfläche cmdNaechster <\/b>an:<\/p>\n Die Prozedur blendet nun zunächst das Listenfeld aus (sofern dieses überhaupt eingeblendet war). Dies ist für den Fall vorgesehen, dass der Benutzer zuerst durch längeres Drücken der Schaltfläche das Listenfeld einblendet, sich dann aber entscheidet, keinen Eintrag über das Listenfeld auszublenden, sondern direkt über die Schaltfläche cmdVorheriger <\/b>zum gewünschten Datensatz zu springen. Dann durchläuft die Prozedur eine For…Next<\/b>-Schleife, und zwar maximal 20 Mal. Im ersten Schritt ruft die Prozedur eine API-Funktion namens Sleep <\/b>auf, die wie folgt im Kopf des Klassenmoduls deklariert wird:<\/p>\n Dies führt schlicht und einfach dazu, dass die Prozedur für zehn Millisekunden angehalten wird. Dann prüft die Prozedur, ob die Variable bolVorheriger<\/b> den Wert False <\/b>enthält. Um es kurz zu machen: Wenn Sie die Maustaste nicht loslassen, ist dies nicht der Fall und die Prozedur läuft weiter.<\/p>\n Dies tut sie maximal solange, bis die Schleife 20 Mal durchlaufen wurde. Dann haben wir 200 Millisekunden gewartet, wenn der Benutzer die Schaltfläche so lange herunterdrückt, soll das Listenfeld lstPopupliste <\/b>eingeblendet werden. Dies erledigen die folgenden Anweisungen. Die erste stellt das Listenfeld auf den Datensatz ein, der aktuell im Formular angezeigt wird – dazu nutzt sie die Value<\/b>-Eigenschaft des Listenfeldes. Die zweite legt mit der Eigenschaft Height <\/b>die Höhe des Listenfeldes fest, damit dieses genau die in der Datensatzherkunft enthaltene Anzahl Datensätze anzeigt. Dabei haben wir den Faktor nach Augenmaß experimentell ermittelt. Schließlich blendet die Einstellung True <\/b>für die Eigenschaft Visible <\/b>das Listenfeld ein. Das war es schon – das Listenfeld wird nun unter der Schaltfläche cmdVorheriger <\/b>eingeblendet.<\/p>\n Wie nun können wir sicherstellen, dass beim Loslassen der Schaltfläche vor dem Ablauf von 200 Millisekunden das Listenfeld nicht eingeblendet und stattdessen einfach der vorherige Datensatz angezeigt wird<\/p>\n Dies erledigen wir mit der Prozedur, die durch das Ereignis Bei Maustaste auf <\/b>ausgelöst wird (s. Listing 5).<\/p>\n Listing 5: Diese Prozedur folgt beim Loslassen der Schaltfläche cmdVorheriger.<\/span><\/b><\/p>\n Diese Prozedur stellt zunächst die Variable bolVorheriger <\/b>auf den Wert False <\/b>ein. Dies sorgt dann auch beim Ablauf der Prozedur cmdVorheriger_MouseDown <\/b>dafür, dass die Abbruchbedingung innerhalb der Schleife wahr ist und diese Prozedur verlassen wird, ohne das Listenfeld lstPopupliste <\/b>einzublenden.<\/p>\n Damit die Prozedur cmdVorheriger_MouseUp <\/b>überhaupt ausgeführt wird, während die Schleife in der Prozedur cmdVorheriger_MouseDown <\/b>durchlaufen wird, bauen wir dort die Anweisung DoEvents <\/b>ein. Anderenfalls würde die Prozedur cmdVorheriger_MouseDown <\/b>immer zuerst bis zum Ende ausgeführt werden, bevor die Prozedur cmdVorheriger_MouseUp <\/b>überhaupt gestartet wird.<\/p>\n Die Prozedur cmdVorheriger_MouseUp <\/b>sorgt also zunächst dafür, dass die Prozedur cmdVorheriger_MouseDown <\/b>bis zum Ende ausgeführt wird.<\/p>\n Dann prüft sie selbst, ob die Maustaste vielleicht solange gedrückt wurde, dass das Listenfeld mittlerweile sichtbar ist. In diesem Fall ist die Prozedur hiermit beendet, der Benutzer kann den gewünschten Datensatz nun aus dem Listenfeld auswählen.<\/p>\n Ist das Listenfeld aber noch nicht sichtbar, ermittelt die Prozedur den Primärschlüsselwert des Kunden, der in der Tabelle tblVerlauf <\/b>für das Feld Popup-listeID <\/b>den Wert -1 <\/b>enthält und somit dem vorherigen Datensatz aus dem Listenfeld entspricht.<\/p>\n Dieser wird dann über die FindFirst<\/b>-Methode des Recordset<\/b>-Objekts des Formulars ausgewählt.<\/p>\n Die beiden Prozeduren, welche die entsprechende Funktionalität für die Schaltfläche cmdNaechster <\/b>bereitstellen, finden Sie übrigens in Listing 6.<\/p>\n Listing 6: Die Prozeduren zum Einblenden der Popupliste oder Auswählen eines Datensatzes für die Schaltfläche cmdNaechster.<\/span><\/b><\/p>\n Anzeigen des gewählten Datensatzes<\/b><\/p>\n Nun fehlt noch der letzte Schritt: Die Auswahl eines der Einträge aus dem Listenfeld.<\/p>\n Wenn Sie einen der Einträge anklicken, löst dies die folgende Prozedur aus:<\/p>\n Dies stellt das Formular auf den im Listenfeld angeklickten Datensatz ein und setzt den Fokus auf das Textfeld KundeID <\/b>des Formulars.<\/p>\n Dies ist nötig, damit wir das Listenfeld lstPopupliste <\/b>ausblenden können – anderenfalls würde dies einen Fehler liefern, weil Sie kein Element ausblenden können, während es noch den Fokus besitzt.<\/p>\n Der Rest wird über die bereits beschriebenen Ereignisprozeduren erledigt, vor allem durch die Prozedur, die durch das Ereignis Beim Anzeigen <\/b>des Formulars ausgelöst wird.<\/p>\n Restarbeiten<\/b><\/p>\n Damit das Formular nach der Auswahl eines neuen Datensatzes aus dem Kombinationsfeld cboAuswahl <\/b>den entsprechenden Datensatz anzeigt, hinterlegen sie für seine Ereigniseigenschaft Nach Aktualisierung <\/b>die folgende Ereignisprozedur:<\/p>\n![\"Anzeige](\"..\/fileadmin\/_temp_\/2014_04\/pic_942_003.png\")
<\/p>\n![\"Entwurf](\"..\/fileadmin\/_temp_\/2014_04\/pic_942_001.png\")
<\/p>\nSELECT tblKunden.KundeID, tblKunden.Firma \r\nFROM tblKunden \r\nORDER BY tblKunden.Firma;<\/pre>\n
Private Sub <\/span>Form_Current()\r\n Me!cboAuswahl = Me!KundeID\r\nEnd Sub<\/span><\/pre>\nPrivate Sub <\/span>cboAuswahl_AfterUpdate()\r\n Me.Recordset.FindFirst \"KundeID = \" & Me!cboAuswahl\r\nEnd Sub<\/span><\/pre>\n![\"Kombinationsfeld](\"..\/fileadmin\/_temp_\/2014_04\/pic_942_004.png\")
<\/p>\n![\"Diese](\"..\/fileadmin\/_temp_\/2014_04\/pic_942_005.png\")
<\/p>\n![\"Die](\"..\/fileadmin\/_temp_\/2014_04\/pic_942_006.png\")
<\/p>\n![\"Dies](\"..\/fileadmin\/_temp_\/2014_04\/pic_942_011.png\")
<\/p>\nPrivate Sub <\/span>Form_Load()\r\n Dim <\/span>db As <\/span>DAO.Database\r\n Set<\/span> db = CurrentDb\r\n db.Execute \"UPDATE tblVerlauf SET PopuplisteID = NULL\", dbFailOnError\r\n Set<\/span> db = Nothing\r\nEnd Sub<\/span><\/pre>\nPrivate Sub <\/span>VerlaufSpeichern(lngPKID As Long<\/span>, strTitel As String<\/span>)\r\n Dim <\/span>db As <\/span>DAO.Database\r\n Set<\/span> db = CurrentDb\r\n On Error Resume Next<\/span>\r\n db.Execute \"INSERT INTO tblVerlauf(PKID, Titel, Zugriffszeit) VALUES(\" _\r\n & lngPKID & \", ''\" & Replace<\/span>(strTitel, \"''\", \"''''\") _\r\n & \"'', \" & ISODatum(Now) & \")\", dbFailOnError\r\n If <\/span>Err.Number = 3022 Then<\/span>\r\n db.Execute \"UPDATE tblVerlauf SET Zugriffszeit = \" & ISODatum(Now) _\r\n & \" WHERE PKID = \" & lngPKID\r\n End If<\/span>\r\n Set<\/span> db = Nothing\r\nEnd Sub<\/span><\/pre>\nPrivate Sub <\/span>PopuplisteAktualisieren()\r\n Dim <\/span>db As <\/span>DAO.Database\r\n Dim <\/span>lngPositionDesAktuellenEintragsInPopupliste As Long<\/span>\r\n Dim <\/span>intDifferenz As Integer<\/span>\r\n Dim <\/span>intAnzahlEintraege As Integer<\/span>\r\n Set<\/span> db = CurrentDb\r\n intAnzahlEintraege = DCount(\"PKID\", \"tblVerlauf\", \"PopuplisteID IS NOT NULL\")\r\n If <\/span>intAnzahlEintraege = 0 Then<\/span>\r\n db.Execute \"UPDATE tblVerlauf SET PopuplisteID = 0 WHERE PKID = \" & Me!KundeID, dbFailOnError\r\n Else<\/span>\r\n lngPositionDesAktuellenEintragsInPopupliste = _\r\n Nz(DLookup(\"PopuplisteID\", \"tblVerlauf\", \"PKID = \" & Me!KundeID), 99)\r\n If <\/span>lngPositionDesAktuellenEintragsInPopupliste = 99 Then<\/span>\r\n db.Execute \"UPDATE tblVerlauf SET PopuplisteID = NULL WHERE PopuplisteID > 0\", dbFailOnError\r\n db.Execute \"UPDATE tblVerlauf Set<\/span> PopuplisteID = PopuplisteID - 1 " _\r\n "WHERE PopuplisteID IS NOT NULL\"\r\n db.Execute \"UPDATE tblVerlauf SET PopuplisteID = \" & DMax(\"PopuplisteID\", \"tblVerlauf\", _\r\n \"PopuplisteID IS NOT NULL\") + 1 & \" WHERE PKID = \" & Me!KundeID, dbFailOnError\r\n Else<\/span>\r\n intDifferenz = lngPositionDesAktuellenEintragsInPopupliste\r\n db.Execute \"UPDATE tblVerlauf SET PopuplisteID = PopuplisteID - \" & intDifferenz _\r\n & \" WHERE PopuplisteID IS NOT NULL\", dbFailOnError\r\n End If<\/span>\r\n End If<\/span>\r\n Set<\/span> db = Nothing\r\nEnd Sub<\/span><\/pre>\n![\"Vier](\"..\/fileadmin\/_temp_\/2014_04\/pic_942_007.png\")
<\/p>\n![\"Der](\"..\/fileadmin\/_temp_\/2014_04\/pic_942_008.png\")
<\/p>\n![\"Der](\"..\/fileadmin\/_temp_\/2014_04\/pic_942_009.png\")
<\/p>\n![\"Das](\"..\/fileadmin\/_temp_\/2014_04\/pic_942_010.png\")
<\/p>\nPrivate Sub <\/span>cmdVorheriger_MouseDown(Button As Integer<\/span>, Shift As Integer<\/span>, X As Single<\/span>, Y As Single<\/span>)\r\n Dim <\/span>i As Integer<\/span>\r\n bolVorheriger = True<\/span>\r\n Me!lstPopupliste.Visible = False<\/span>\r\n For i = 1 To 20\r\n Sleep 10\r\n DoEvents\r\n If <\/span>bolVorheriger = False<\/span> Then<\/span>\r\n Exit Sub<\/span>\r\n End If<\/span>\r\n Next<\/span> i\r\n With<\/span> Me!lstPopupliste\r\n .Value = Me!KundeID\r\n .Height = Me!lstPopupliste.ListCount * 300\r\n .Visible = True<\/span>\r\n End With<\/span>\r\nEnd Sub<\/span><\/pre>\nDim <\/span>bolVorheriger As Boolean<\/span><\/pre>\nDim <\/span>bolNaechster As Boolean<\/span><\/pre>\nPrivate <\/span>Declare Sub Sleep Lib \"kernel32\" (ByVal dwMilliseconds As Long<\/span>)<\/pre>\nPrivate Sub <\/span>cmdVorheriger_MouseUp(Button As Integer<\/span>, Shift As Integer<\/span>, X As Single<\/span>, Y As Single<\/span>)\r\n Dim <\/span>lngKundeID As Long<\/span>\r\n bolVorheriger = False<\/span>\r\n If <\/span>Me!lstPopupliste.Visible = False<\/span> Then<\/span>\r\n lngKundeID = DLookup(\"PKID\", \"tblVerlauf\", \"PopuplisteID = -1\")\r\n Me.Recordset.FindFirst \"KundeID = \" & lngKundeID\r\n End If<\/span>\r\nEnd Sub<\/span><\/pre>\nPrivate Sub <\/span>cmdNaechster_MouseDown(Button As Integer<\/span>, Shift As Integer<\/span>, X As Single<\/span>, Y As Single<\/span>)\r\n Dim <\/span>i As Integer<\/span>\r\n bolNaechster = True<\/span>\r\n Me!lstPopupliste.Visible = False<\/span>\r\n For i = 1 To 20\r\n Sleep 10\r\n DoEvents\r\n If <\/span>bolNaechster = False<\/span> Then<\/span>\r\n Exit Sub<\/span>\r\n End If<\/span>\r\n Next<\/span> i\r\n With<\/span> Me!lstPopupliste\r\n .Value = Me!KundeID\r\n .Height = Me!lstPopupliste.ListCount * 300\r\n .Visible = True<\/span>\r\n End With<\/span>\r\nEnd Sub<\/span>\r\nPrivate Sub <\/span>cmdNaechster_MouseUp(Button As Integer<\/span>, Shift As Integer<\/span>, X As Single<\/span>, Y As Single<\/span>)\r\n Dim <\/span>lngKundeID As Long<\/span>\r\n bolNaechster = False<\/span>\r\n If <\/span>Me!lstPopupliste.Visible = False<\/span> Then<\/span>\r\n lngKundeID = DLookup(\"PKID\", \"tblVerlauf\", \"PopuplisteID = 1\")\r\n Me.Recordset.FindFirst \"KundeID = \" & lngKundeID\r\n End If<\/span>\r\nEnd Sub<\/span><\/pre>\nPrivate Sub <\/span>lstPopupliste_Click()\r\n Me.Recordset.FindFirst \"KundeID = \" _\r\n & Me!lstPopupliste\r\n Me!KundeID.SetFocus\r\n Me!lstPopupliste.Visible = False<\/span>\r\nEnd Sub<\/span><\/pre>\nPrivate Sub <\/span>cboAuswahl_AfterUpdate()\r\n Me.Recordset.FindFirst _\r\n \"KundeID = \" & Me!cboAuswahl\r\nEnd Sub<\/span><\/pre>\n