<\/p>\n
Wann immer Kriterien sich nicht nach dem Alphabet oder nach einem Zahlenwert sortieren lassen und eine individuelle Sortierung gefordert ist, entsteht Programmieraufwand. Sie müssen die betroffene Datenherkunft um ein Sortierfeld erweitern und einige Schaltflächen oder anderweitige Möglichkeiten zum Einstellen der Sortierung bereitstellen. Dieser Beitrag stellt eine Klasse vor, mit der Sie die benötigten Techniken mit wenigen Codezeilen einbinden.<\/b><\/p>\n
In diesem Beitrag lernen Sie zunächst zwei Anwendungsfälle für den Einsatz der Reihenfolge-Klasse clsOrder <\/b>kennen:<\/p>\n Anschließend erfahren Sie mehr über die in der Klasse verwendete Technik, um später eigene Anpassungen vornehmen zu können. In beiden Fällen sollen Daten der Tabelle tblKategorien <\/b>der Südsturm-Datenbank angezeigt und sortiert werden. Damit dies funktioniert, fügen Sie der Tabelle ein Feld namens ReihenfolgeID<\/b> hinzu (s. Bild 1).<\/p>\n Bild 1: Kategorientabelle mit dem Feld ReihenfolgeID<\/span><\/b><\/p>\n Reihenfolge in Listenfeldern<\/b><\/p>\n Um die Daten dieser Tabelle in einem Listenfeld darzustellen und die Datensätze durch ändern des Wertes des Feldes ReihenfolgeID <\/b>in der entsprechenden Reihenfolge darzustellen, fügen Sie einem neuen, leeren Formular zunächst ein entsprechendes Listenfeld hinzu. Damit das Listenfeld zu Testzwecken auch den Wert des Feldes ReihenfolgeID <\/b>anzeigt, stellen Sie zunächst die Eigenschaft Datensatzherkunft <\/b>auf den folgenden Ausdruck ein – dies sorgt gleichzeitig für die Darstellung in der richtigen Reihenfolge:<\/p>\n Außerdem legen Sie für die beiden Eigenschaften Spaltenanzahl <\/b>und Spaltenbreiten <\/b>die beiden Werte 3 <\/b>und 0cm;5cm <\/b>fest. Auf diese Weise wird der Primärschlüsselwert verborgen, der Kategoriename wird in einer Breite von 5cm <\/b>angezeigt und der Wert des Feldes ReihenfolgeID <\/b>nimmt den übrigen Platz ein (das Listenfeld sollte eine entsprechende Breite aufweisen, also etwa 6cm<\/b>). Das Listenfeld soll den Namen lstKontakte <\/b>erhalten.<\/p>\n Außerdem fügen Sie dem Formular vier Schaltflächen namens cmdTop<\/b>, cmdBottom<\/b>, cmdUp <\/b>und cmdDown<\/b> hinzu (s. Bild 2).<\/p>\n Bild 2: Vorbereitung des Listenfeldes mit Schaltflächen zum ändern der Reihenfolge<\/span><\/b><\/p>\n Nun beginnt der interessante Teil: Das Formular soll mit entsprechender Funktionalität ausgestattet werden. Diese steckt komplett in der Klasse clsOrder<\/b>.<\/p>\n Sie müssen diese Klasse nun instanzieren, mit einer im Klassenmodul des Formulars deklarierten Objektvariablen referenzieren und einige Eigenschaften für dieses Objekt festlegen. Zu guter Letzt rufen Sie auch noch eine Methode dieser Klasse auf.<\/p>\n Grundvoraussetzung ist also, dass sich die Klasse clsOrder <\/b>in der gleichen Datenbank befindet.<\/p>\n Sollten Sie die Beispiele in einer neuen Datenbank ausprobieren wollen, importieren Sie also diese Klasse aus der Beispieldatenbank in die Zieldatenbank (Sie können auch den kompletten Quellcode der Klasse kopieren, in ein neues Klassenmodul einfügen und dieses unter dem Namen clsOrder<\/b> speichern).<\/p>\n Danach weisen Sie der Eigenschaft Beim Laden <\/b>des Formulars den Wert [Ereignisprozedur] <\/b>zu und klicken auf die Schaltfläche mit den drei Punkten, um die entsprechende Ereignisprozedur anzulegen. Fügen Sie im Kopf des Moduls die folgende Deklarationszeile ein:<\/p>\n Komplettieren Sie dann die Ereignisprozedur Form_Load <\/b>wie folgt, wobei Sie die Eigenschaften und Methoden ganz einfach wie in Bild 3 per IntelliSense auswählen:<\/p>\n Bild 3: Auswahl von Eigenschaften und Methoden der Klasse clsOrder per IntelliSense<\/span><\/b><\/p>\n Die erste Zeile erzeugt zunächst eine neue Instanz der Klasse clsOrder <\/b>und speichert einen Verweis darauf in der Objektvariablen objOrder<\/b>. <\/p>\n Die zweite Zeile legt fest, dass die Sortierfunktion auf die Daten des Listenfeldes lstKontakte <\/b>angewendet werden soll. Dazu übergeben Sie einen Verweis auf dieses Steuerelement an die Eigenschaft Listbox<\/b>. Die Eigenschaft Table <\/b>legt fest, auf welche Tabelle sich die änderung der Reihenfolge bezieht – in diesem Falle tblKategorien<\/b>.<\/p>\n Sie können auch eine Abfrage angeben, diese muss jedoch aktualisierbar sein. Der Eigenschaft OrderField <\/b>übergeben Sie den Namen des Feldes, nach dem die Daten sortiert werden sollen, also ReihenfolgeID<\/b>. PrimaryKeyField <\/b>erwartet schließlich den Namen des Primärschlüsselfeldes der Tabelle, hier KontaktID<\/b>.<\/p>\n Die folgenden vier Anweisungen definieren, welche Schaltflächen mit den Funktionen zum ändern der Reihenfolge versehen werden sollen. Schließlich rufen Sie noch die Methode FillOrderID<\/b> auf. Diese Methode füllt eventuell noch leere Sortierfelder mit den entsprechenden Zahlenwerten auf.<\/p>\n Wenn Sie nun in die Formularansicht wechseln, können Sie die Schaltflächen direkt einsetzen, um die Reihenfolge des aktuell aktivierten Eintrags im Listenfeld zu ändern – vorausgesetzt, es ist überhaupt ein Eintrag aktiviert.<\/p>\n Wenn das Listenfeld beim Öffnen den Wert Null <\/b>hat, ist keine der Schaltflächen aktiviert. Klicken Sie auf das oberste Listenelement, werden die beiden Schaltflächen zum Verschieben des aktuellen Eintrags ganz nach oben oder um eine Position nach oben deaktiviert (siehe Bild 4). Ist hingegen der unterste Eintrag ausgewählt, sind die beiden Schaltflächen zum Verschieben des aktuellen Eintrags um eine Position nach unten oder ganz nach unten deaktiviert.<\/p>\n Bild 4: Listenfeld mit aktiven Reihenfolge-Funktionen<\/span><\/b><\/p>\n Reihenfolge für Unterformulare<\/b><\/p>\n Die gleiche Technik funktioniert auch für Formulare, die Daten einer Tabelle in einem Unterformular in der Datenblattansicht anzeigen (Gleiches gilt für Endlosformulare). In der Beispieldatenbank finden Sie zwei Formulare namens frmKategorien <\/b>und sfmKategorien<\/b>, wobei Letzteres als Unterformular in der Datenblattansicht definiert ist.<\/p>\n Das Unterformular ist über die Eigenschaft Datenherkunft <\/b>an die Tabelle tblKategorien <\/b>gebunden und zeigt die drei Felder KategorieID<\/b>, Kategoriename <\/b>und ReihenfolgeID <\/b>an (s. Bild 5). Auch hier gibt es vier Schaltflächen, die in diesem Fall cmdGanzNachUnten<\/b>, cmdNachUnten<\/b>, cmdNachOben <\/b>und cmdGanzNachOben <\/b>heißen.<\/p>\n Bild 5: Konstellation mit Haupt- und Unterformular<\/span><\/b><\/p>\n Der Code zum Einbinden und Aktivieren des Klassenmoduls clsOrder <\/b>sieht hier ein wenig anders aus:<\/p>\n Der große Unterschied liegt darin, dass hier nicht die Eigenschaft Listbox<\/b>, sondern die Eigenschaft Datasheet <\/b>gefüllt wird – in diesem Fall mit einem Verweis auf das im Unterformularsteuerelement enthaltene Formular.<\/p>\n Datenblatt-Spezialitäten<\/b><\/p>\n Wenn Sie die Reihenfolge von Daten im Datenblatt ändern möchten, müssen Sie eigentlich einiges beachten: So kann es ja zum Beispiel vorkommen, dass der Datensatzzeiger auf dem neuen Datensatz landet, dass ein Datensatz gelöscht wird oder dass der Benutzer einen neuen Datensatz anlegt. Die Klasse clsOrder <\/b>kümmert sich um all diese Fälle: Beim Anlegen eines neuen Datensatzes werden die Schaltflächen zum Verschieben des Datensatzes bis zum Speichern zunächst deaktiviert.<\/p>\n Erst nach dem Speichern des Datensatzes weist clsOrder <\/b>dem Feld ReihenfolgeID <\/b>einen Wert zu, der dem größten bisher vergebenen Wert plus eins entspricht. Außerdem werden dann wieder die entsprechenden Schaltflächen zum ändern der Reihenfolge aktiviert beziehungsweise deaktiviert.<\/p>\n Vorstellung der verwendeten Techniken<\/b><\/p>\n Für Access-Entwickler, die selbst Hand an die Klasse clsOrder <\/b>anlegen möchten, um Anpassungen durchzuführen, folgt nun der technisch interessante Teil des Beitrags. Die Klasse verwendet zunächst einmal vier Objektvariablen, welche die Verweise zu den vier Schaltflächen zum Einstellen der Reihenfolge aufnehmen sollen:<\/p>\n Diese Objektvariablen sind mit dem Schlüsselwort WithEvents <\/b>gekennzeichnet, damit wir innerhalb dieser Klasse Ereignisprozeduren für die mit den Variablen referenzierten Objekte definieren können.<\/p>\n Immerhin soll ja die komplette Funktionalität beim Klicken der Schaltflächen in der Klasse clsOrder <\/b>enthalten sein und nicht im Klassenmodul des Formulars – dieses soll nur die paar Konfigurationsanweisungen aufnehmen.<\/p>\n Wenn Sie per VBA etwa die Eigenschaft CommandButton_Up <\/b>mit einem Verweis auf die Schaltfläche cmdNachOben <\/b>füllen, löst dies die folgende Prozedur aus:<\/p>\n Diese versieht die Objektvariable m_Up<\/b> mit dem Verweis auf die betroffene Schaltfläche. Danach wird die Objektvariable m_Form <\/b>mit einem Verweis auf das Parent<\/b>-Objekt der Schaltfläche gefüllt, also dem Formular, in dem diese sich befindet.<\/p>\n Der Eigenschaft OnCurrent <\/b>der Objektvariable m_Form <\/b>wird der Wert [Event Procedure]<\/b> zugewiesen, was gleichbedeutend mit dem Füllen der Eigenschaft Beim Anzeigen <\/b>mit [Ereignisprozedur] <\/b>im Eigenschaftsfenster ist.<\/p>\n Nur dass Access in diesem Fall nicht im Klassenmodul des Formulars, sondern im aktuellen Klassenmodul clsOrder <\/b>nach einer entsprechenden Ereignisprozedur sucht. Im gleichen Zuge wird auch noch die Eigenschaft OnClick <\/b>der soeben referenzierten Schaltfläche mit [Event Procedure] <\/b>gefüllt.<\/p>\n Die Prozeduren für die übrigen Schaltflächen sind prinzipiell genau gleich aufgebaut. Dass alle die Objektvariable m_Form <\/b>füllen, liegt daran, dass nicht zwangsläufig alle Schaltflächen verwendet werden. Das Formular der Schaltfläche soll jedoch auf jeden Fall referenziert werden. Die Variable für das Formular wird so deklariert:<\/p>\n Außerdem soll entweder ein Listenfeld oder ein Unterformular angegeben werden, dessen Daten mit den angegebenen Schaltflächen sortiert werden können. Der entsprechende Verweis landet in einer der beiden folgenden Objektvariablen:<\/p>\n Das Zuweisen des Listbox-Steuerelements ist ganz einfach. Hier werden nur der Verweis auf das Listenfeld übergeben und die Ereignisprozedur Nach Aktualisierung <\/b>vorbereitet:<\/p>\n Diese Ereignisprozedur soll später dafür sorgen, dass je nach aktiviertem Listenfeldeintrag die richtigen Schaltflächen aktiviert werden.<\/p>\n Beim Unterformular kommen noch zwei weitere Ereignisprozeduren hinzu, eine wird ersetzt – außerdem wird die Referenz auf das Unterformular in der Variablen m_Datasheet <\/b>gespeichert:<\/p>\n Die Ereignisprozedur AfterUpdate <\/b>des Listenfeldes wird durch BeforeUpdate <\/b>ersetzt. Der Grund: Es kann sein, dass dieses Ereignis durch das Anlegen eines neuen Datensatzes ausgelöst wird. In diesem Fall soll vor dem Speichern noch ein entsprechender Wert in das Feld zur Festlegung der Reihenfolge (im Beispiel ReihenfolgeID<\/b>) eingetragen werden. Das Ereignis Beim Anzeigen <\/b>(OnCurrent<\/b>) wird bei jedem Datensatzwechsel ausgelöst, das Ereignis Beim Löschen <\/b>(OnDelete<\/b>) beim Löschen eines Datensatzes.<\/p>\n <\/p>\n Die drei Eigenschaften Table<\/b>, PrimaryKeyField <\/b>und OrderField <\/b>werden für Unterformulare wie auch für Listenfelder gleichermaßen benötigt. Die entsprechenden Werte landen nach der Zuweisung an die entsprechenden Eigenschaften in diesen lokalen Variablen:<\/p>\n Die Property Let<\/b>-Prozeduren, welche die entsprechenden Eigenschaften bereitstellen, nehmen schlicht die übergebenen Werte entgegen und tragen diese in die oben deklarierten Variablen ein:<\/p>\n Außerdem muss zur ordnungsgemäßen Funktion einmalig die Methode FillOrderID<\/b> aufgerufen werden. Diese sieht wie in Listing 1<\/a><\/span> aus und ruft zunächst eine Funktion namens CheckMembers <\/b>auf.<\/p>\n Listing 1: Sortierung per Reihenfolge-Feld aktualisieren<\/p>\n Diese Funktion nimmt einige Prüfungen vor, welche die Funktionsfähigkeit der Klasse sicherstellen. Sind die Prüfungen nicht erfolgreich, wird die Prozedur abgebrochen – mehr dazu weiter unten.<\/p>\n Danach öffnet die Prozedur ein Recordset, das auf der als Datenherkunft verwendeten Tabelle basiert und nach dem Feld sortiert ist, das die Werte für die Reihenfolge enthält. In dieser Reihenfolge durchläuft die Prozedur alle enthaltenen Datensätze und füllt das Feld für die Reihenfolge mit durchnummerierten Werten. <\/p>\n Variablen prüfen<\/p>\n Die Funktion CheckMembers <\/b>prüft, ob der Benutzer die für den Einsatz der Klasse benötigten Informationen beim Öffnen des Formulars angegeben hat und liefert je nach Ergebnis den Wert True <\/b>oder False <\/b>zurück (s. Listing 2<\/a><\/span>). Das Ergebnis wird darüber hinaus in der wie folgt deklarierten und modulweit gültigen Variablen bolMembersChecked <\/b>gespeichert:<\/p>\n Listing 2: Prüfung, ob alle notwendigen Informationen vorliegen<\/p>\n Dies ist notwendig, weil CheckMembers <\/b>zu späteren Gelegenheiten wiederholt aufgerufen wird. Hat bolMembersChecked<\/b> dann den Wert True<\/b>, wird die Funktion gleich wieder beendet.<\/p>\n Die Funktion prüft folgende Zustände:<\/p>\n Diese Prüfungen sollen auf jeden Fall durchgeführt werden, bevor die übrigen Anweisungen der Prozedur FillOrderID <\/b>ausgeführt werden.<\/p>\n Gegebenenfalls ruft die Form_Load<\/b>-Ereignisprozedur des Formulars FillOrderID<\/b> aber gar nicht auf. Damit die Prüfung dennoch zumindest vor dem ersten ändern der Sortierung erfolgt, werden beim Zuweisen der bis zu vier Schaltflächen die bereits weiter oben vorgestellten Anweisungen ausgelöst:<\/p>\n Dies sorgt dafür, dass eine Ereignisprozedur ausgeführt wird, und zwar für das Ereignis Beim Anzeigen <\/b>des Formulars, in dem sich die Schaltflächen befinden. Dieses Ereignis wird auf jeden Fall nach dem Ereignis Beim Laden <\/b>ausgeführt, das ja überhaupt erst die Klasse clsOrder <\/b>instanziert. Dies bietet eine weitere Möglichkeit, die Funktion CheckMembers <\/b>aufzurufen.<\/p>\n Gleichzeitig wird die Prozedur ActivateControls <\/b>gestartet, welche die Schaltflächen abhängig vom aktuell markierten Datensatz aktiviert oder deaktiviert:<\/p>\n Die Prozedur ActivateControls <\/b>führt mehrere Prüfungen durch und aktiviert oder deaktiviert die verwendeten Schaltflächen (s. Listing 3<\/a><\/span>). Genau genommen aktiviert sie zunächst alle vier Schaltflächen, wobei sie zuvor sicherstellt, dass diese überhaupt referenziert wurden – sonst geschieht nichts. Danach werden die Schaltflächen je nach bestimmten Zuständen deaktiviert.<\/p>\n Listing 3: Aktivieren\/Deaktivieren der Schaltflächen<\/p>\n Die erste Unterscheidung betrifft das verwendete Steuerelement zur Darstellung der Daten. Handelt es sich um ein Unterformular oder ein Listenfeld Beim Unterformular kann es sein, dass der Benutzer soeben einen Datensatz gelöscht hat, was sich im Wert True <\/b>für die Variable bolDelete <\/b>niederschlägt (mehr dazu weiter unten).<\/p>\n Wurde also zuletzt ein Datensatz gelöscht, deaktiviert die Prozedur alle vier Schaltflächen durch den Aufruf der Prozeduren EnableUp <\/b>und EnableDown<\/b>. EnableUp <\/b>deaktiviert die beiden Schaltflächen, die Einträge nach oben verschieben:<\/p>\n EnableDown <\/b>erledigt dies für Einträge, die weiter unten landen sollen:<\/p>\n Außerdem wird bolDelete <\/b>auf False <\/b>eingestellt, da diese Variable ausschließlich für den Einsatz in der aktuellen Prozedur Verwendung findet. Sollte ActiveControls <\/b>beim nächsten Mal wieder durch das Löschen eines Datensatzes ausgelöst werden, wird bolDelete <\/b>wieder den Wert True <\/b>enthalten. Handelt es sich um das einfache Wechseln zu einem anderen Datensatz, erhält bolDelete <\/b>den Wert False<\/b>.<\/p>\n EnableUp <\/b>und EnableDown <\/b>werden ebenfalls aufgerufen, wenn der aktuelle Datensatz neu ist. Dieser darf erst nach dem Speichern verschoben werden, da er erst dann einen Wert im Feld für die Reihenfolge erhält.<\/p>\n In allen anderen Fällen prüft ActivateControls <\/b>die Position des Datensatzzeigers im Unterformular (m_Datasheet.Recordset.AbsolutePosition<\/b>) in einer Select Case<\/b>-Anweisung.<\/p>\n Lautet dieser Wert 0<\/b>, befindet sich der Datensatzzeiger auf dem ersten Datensatz. In diesem Fall werden die Schaltflächen zum Verschieben nach oben deaktiviert. Befindet sich der Datensatzzeiger auf dem letzten Datensatz (m_Datasheet.Recordset.RecordCount – 1<\/b>), sollen die Schaltflächen zum Verschieben des Datensatzes nach unten deaktiviert werden. Entspricht der Wert der aktuellen Anzahl der Datensätze oder hat dieser den Wert -1<\/b>, sollen alle Schaltflächen deaktiviert werden.<\/p>\n Die Prüfung der Einträge des Listenfeldes ist erheblich einfacher. Entspricht der Wert der Eigenschaft ListIndex <\/b>dem Wert 0<\/b>, wurde der erste Eintrag markiert – dementsprechend sollen die Schaltflächen zum Verschieben nach oben deaktiviert werden. Ist ListIndex <\/b>hingegen mit m_Listbox.ListCount – 1 + m_Listbox.ColumnHeads <\/b>identisch, befindet sich die Markierung auf dem untersten Datensatz.<\/p>\n Normalerweise reicht der Ausdruck m_Listbox.ListCount – 1<\/b> aus, um diese Position zu erkennen. Es kann jedoch sein, dass das Listenfeld Spaltenüberschriften anzeigt – dadurch wird ListCount <\/b>um eins größer. Dies kompensieren wir durch das Addieren des Wertes der Eigenschaft ColumnHeads<\/b>, die bei Verwendung von Spaltenüberschriften den Wert True<\/b>, also -1<\/b>, liefert, was genau der einen Zeile entspricht, die bei Verwendung von Spaltenüberschriften zu viel ist. Hat das Listenfeld-Steuerelement den Wert Null<\/b>, sollen alle Schaltflächen deaktiviert werden.<\/p>\n Aktualisieren des Unterformulars<\/b><\/p>\n Damit die Schaltflächen beim Wechsel des Datensatzes im Unterformular aktiviert beziehungsweise deaktiviert werden können, müssen Sie diese Aktion durch eine entsprechende Ereignisprozedur abfangen. Dies erledigt das Ereignis Beim Anzeigen <\/b>des Unterformulars, das wir diesem ebenfalls über die entsprechende Objektvariable unterjubeln:<\/p>\n Aktualisieren des Listenfeldes<\/b><\/p>\n Auch beim Auswählen eines neuen Eintrags im Listenfeld müssen die Schaltflächen zum ändern der Reihenfolge gegebenenfalls aktiviert beziehungsweise deaktiviert werden. Dies erledigt die folgende Prozedur, die durch das Ereignis Nach Aktualisierung <\/b>des Listenfeldes ausgelöst wird:<\/p>\n Neuen Datensatz mit Reihenfolge-Nummer versehen<\/b><\/p>\n Der Benutzer soll im Unterformular natürlich auch neue Datensätze anlegen können, und zwar durch Eintragen der entsprechenden Daten unten in der Zeile mit dem neuen, leeren Datensatz. Dabei ist es wichtig, dass auch der neue Datensatz gleich einen Wert für das Feld zur Bestimmung der Reihenfolge (in den Beispielen ReihenfolgeID<\/b>) erhält. Dazu enthält das Klassenmodul eine Ereignisprozedur, die durch das Ereignis Vor Aktualisierung <\/b>ausgelöst wird und die wie folgt aussieht:<\/p>\n Die Prozedur prüft, ob der aktuelle Datensatz ein neuer Datensatz ist, und ruft gegebenenfalls die Funktion FillNewOrderID <\/b>auf:<\/p>\n Diese Prozedur ermittelt zunächst den bisher größten vergebenen Wert für das Reihenfolge-Feld. Dieser Wert wird um eins erhöht und dem Reihenfolge-Feld des neuen Datensatzes zugewiesen, bevor dieser endgültig gespeichert wird.<\/p>\n Löschen von Datensätzen<\/b><\/p>\n Beim Einsatz eines Unterformulars kann es geschehen, dass der Benutzer einen Datensatz löscht. In der Regel müssen die Schaltflächen zum ändern der Reihenfolge dann entsprechend aktiviert beziehungsweise deaktiviert werden. Dies geschieht wie oben bereits beschrieben in der Prozedur ActivateControls<\/b>. Allerdings muss die Variable bolDelete<\/b>, die wie folgt deklariert wird, zuvor auf den Wert True <\/b>eingestellt werden:<\/p>\n Dies geschieht in einer Ereignisprozedur, die wie folgt aussieht:<\/p>\n Damit die Ereignisprozedur auch ausgelöst wird, wird wie bereits weiter oben beschrieben die Eigenschaft OnDelete <\/b>des Unterformulars auf den Wert [Event Procedure] <\/b>eingestellt:<\/p>\n Reihenfolge ändern<\/b><\/p>\n Kommen wir zum eigentlichen Sinn der Klasse: dem ändern der Reihenfolge-Werte einer Tabelle. Ausgelöst wird dies durch das Anklicken einer der vier Schaltflächen, die durch die Objektvariablen m_Top<\/b>, m_Bottom<\/b>, m_Up <\/b>und m_Down <\/b>referenziert wurden. Wenn der Benutzer beispielsweise auf m_Top <\/b>klickt, soll die folgende Ereignisprozedur ausgelöst werden:<\/p>\n Diese Prozedur ermittelt, sofern gerade ein Unterformular zur Anzeige der Daten verwendet wird, zunächst den Primärschlüsselwert des zu verschiebenden Datensatzes und speichert diesen in der wie folgt modulweit deklarierten Variablen:<\/p>\n Dieser wird benötigt, damit der Datensatz nach dem Aktualisieren des Unterformulars wieder markiert werden kann. Dann liest sie mit der Funktion GetMove <\/b>den Reihenfolge-Wert des aktuell im Listenfeld oder im Datenblatt ausgewählten Datensatzes aus.<\/p>\n Beim Datenblatt gelingt dies ganz einfach, indem Sie den Wert des Reihenfolge-Feldes abfragen. Beim Listenfeld wird zunächst der Wert der gebundenen Spalte des aktuell ausgewählten Eintrags ermittelt und dann mittels DLookup<\/b>-Anweisung der Wert des entsprechenden Reihenfolge-Feldes:<\/p>\n Top<\/b> bedeutet, dass es ganz nach oben gehen soll – also soll der aktuelle Datensatz den Platz des obersten Datensatzes einnehmen und alle zwischen der aktuellen und der Zielposition befindlichen Datensätze um eine Position nach unten schieben. Dementsprechend ermittelt die Prozedur zunächst die Reihenfolge-ID des Zieldatensatzes und speichert diesen in der Variablen lngTarget<\/b>. Dann ruft sie die Prozedur InterchangeOrder <\/b>auf, welche die änderung der Reihenfolge-Werte durchführt – mehr siehe weiter unten. Anschließend aktualisiert die RequeryControls<\/b>-Prozedur noch die Steuerelemente beziehungsweise das Listenfeld oder das Unterformular:<\/p>\n Die Prozedur enthält wieder zwei Bereiche für Unterformulare und Listenfelder. Handelt es sich beim zu aktualisierenden Steuerelement um ein Unterformular, wird dessen Requery<\/b>-Methode aufgerufen und mit der FindFirst<\/b>-Methode der Fokus wieder auf das verschobene Steuerelement gelegt. Listenfelder brauchen einfach nur aktualisiert zu werden, sie behalten die Markierung des Steuerelements einfach bei.<\/p>\n Anschließend ruft die Prozedur noch die Routine ActivateControls <\/b>auf, um gegebenenfalls Schaltflächen zu aktivieren oder zu deaktivieren. Die Prozedur zum Verschieben eines Eintrags an das Ende der Liste sieht so ähnlich wie die Prozedur zum Verschieben an die erste Position aus, daher beschreiben wir diese hier nicht explizit.<\/p>\n Interessanter ist da schon die Prozedur, die einen Eintrag um eine Position nach oben schiebt – und hier speziell die Ermittlung des Eintrags, mit dem die Position getauscht werden soll. Dies gelingt wie folgt:<\/p>\n Der Zieleintrag wird mit dem Aufruf der DMax<\/b>-Funktion ermittelt, wobei der größte Wert für das Reihenfolge-Feld ermittelt wird, der kleiner als der entsprechende Wert des zu verschiebenden Elements ist. Danach erfolgt das Vertauschen der Reihenfolge wiederum mit der Prozedur InterchangeOrder <\/b>– gefolgt vom Aktualisieren der Steuerelemente.<\/p>\n ändern der Reihenfolge<\/b><\/p>\n\n
![\"pic001.png\"](\"..\/fileadmin\/_temp_\/2012_01\/ReihenfolgeMitKlasse-web-images\/pic001.png\")
<\/p>\nSELECT tblKategorien.KategorieID, tblKategorien.Kategoriename, tblKategorien.ReihenfolgeID\r\nFROM tblKategorien ORDER BY tblKategorien.ReihenfolgeID;<\/pre>\n
![\"pic002.png\"](\"..\/fileadmin\/_temp_\/2012_01\/ReihenfolgeMitKlasse-web-images\/pic002.png\")
<\/p>\nDim objOrder As clsOrder<\/pre>\n
![\"pic005.png\"](\"..\/fileadmin\/_temp_\/2012_01\/ReihenfolgeMitKlasse-web-images\/pic005.png\")
<\/p>\nPrivate Sub Form_Load()\r\n Set objOrder = New clsOrder\r\n With objOrder\r\n Set .Listbox = Me!lstKontakte\r\n .Table = "tblKategorien"\r\n .OrderField = "ReihenfolgeID"\r\n .PrimaryKeyField = "KategorieID"\r\n Set .Commandbutton_Top = Me!cmdTop\r\n Set .Commandbutton_Bottom = Me!cmdBottom\r\n Set .Commandbutton_Up = Me!cmdUp\r\n Set .Commandbutton_Down = Me!cmdDown\r\n .FillOrderID\r\n End With\r\nEnd Sub<\/pre>\n
![\"pic003.png\"](\"..\/fileadmin\/_temp_\/2012_01\/ReihenfolgeMitKlasse-web-images\/pic003.png\")
<\/p>\n![\"pic004.png\"](\"..\/fileadmin\/_temp_\/2012_01\/ReihenfolgeMitKlasse-web-images\/pic004.png\")
<\/p>\nDim objOrder As clsOrder\r\nPrivate Sub Form_Load()\r\n Set objOrder = New clsOrder\r\n With objOrder\r\n Set .Datasheet = Me!sfmKategorien.Form\r\n .OrderField = "ReihenfolgeID"\r\n .PrimaryKeyField = "KategorieID"\r\n .Table = "tblKategorien"\r\n Set .Commandbutton_Bottom = Me!cmdGanzNachUnten\r\n Set .Commandbutton_Down = Me!cmdNachUnten\r\n Set .Commandbutton_Top = Me!cmdGanzNachOben\r\n Set .Commandbutton_Up = Me!cmdNachOben\r\n .FillOrderID\r\n End With\r\nEnd Sub<\/pre>\n
Private WithEvents m_Up As CommandButton\r\nPrivate WithEvents m_Down As CommandButton\r\nPrivate WithEvents m_Top As CommandButton\r\nPrivate WithEvents m_Bottom As CommandButton<\/pre>\n
Public Property Set Commandbutton_Up(cmd As CommandButton)\r\n Set m_Up = cmd\r\n Set m_Form = cmd.Parent\r\n m_Form.OnCurrent = "[Event Procedure]"\r\n m_Up.OnClick = "[Event Procedure]"\r\nEnd Property<\/pre>\n
Private WithEvents m_Form As Form<\/pre>\n
Private WithEvents m_Datasheet As Form\r\nPrivate WithEvents m_Listbox As Listbox<\/pre>\n
Public Property Set Listbox(lst As Listbox)\r\n Set m_Listbox = lst\r\n m_Listbox.AfterUpdate = "[Event Procedure]"\r\nEnd Property<\/pre>\n
Public Property Set Datasheet(frm As Form)\r\n Set m_Datasheet = frm\r\n m_Datasheet.OnCurrent = "[Event Procedure]"\r\n m_Datasheet.BeforeUpdate = "[Event Procedure]"\r\n m_Datasheet.OnDelete = "[Event Procedure]"\r\nEnd Property<\/pre>\n
Private m_PKField As String\r\nPrivate m_Orderfield As String\r\nPrivate m_Table As String<\/pre>\n
Public Property Let Table(str As String)\r\n m_Table = str\r\nEnd Property\r\nPublic Property Let PrimaryKeyField(str As String)\r\n m_PKField = str\r\nEnd Property\r\nPublic Property Let OrderField(str As String)\r\n m_Orderfield = str\r\nEnd Property<\/pre>\n
Public Sub FillOrderID()\r\n Dim db As DAO.Database\r\n Dim rst As DAO.Recordset\r\n If CheckMembers = False Then\r\n Exit Sub\r\n End If\r\n Set db = CodeDb\r\n Set rst = db.OpenRecordset("SELECT " & m_PKField & ", " & m_Orderfield & " FROM " & m_Table _\r\n & " ORDER BY " & m_Orderfield, dbOpenDynaset)\r\n Do While Not rst.EOF\r\n rst.Edit\r\n rst(m_Orderfield) = rst.AbsolutePosition + 1\r\n rst.Update\r\n rst.MoveNext\r\n Loop\r\nEnd Sub<\/pre>\nPrivate Function CheckMembers() As Boolean\r\n If Not bolMembersChecked Then\r\n If Len(m_Table) = 0 Then\r\n MsgBox "Geben Sie eine Tabelle für die Klasse clsOrder an."\r\n Exit Function\r\n End If\r\n If Len(m_Orderfield) = 0 Then\r\n MsgBox "Geben Sie das Feld an, dass die Reihenfolge enthält."\r\n Exit Function\r\n End If\r\n If Len(m_PKField) = 0 Then\r\n MsgBox "Geben Sie das Primärschlüsselfeld der Datenherkunft an."\r\n Exit Function\r\n End If\r\n If m_Datasheet Is Nothing And m_Listbox Is Nothing Then\r\n MsgBox "Sie müssen ein Datenblatt oder ein Listenfeld zur Anzeig der Daten festlegen."\r\n Exit Function\r\n Else\r\n If Not m_Datasheet Is Nothing Then\r\n If m_Datasheet.HasModule = False Then\r\n MsgBox "Das Unterformular muss ein Klassenmodul enthalten."\r\n Exit Function\r\n End If\r\n End If\r\n End If\r\n If Not m_Datasheet Is Nothing And Not m_Listbox Is Nothing Then\r\n MsgBox "Sie dürfen nur ein Datenblatt oder ein Listenfeld für die Sortierung angeben."\r\n Exit Function\r\n End If\r\n CheckMembers = True\r\n Else\r\n bolMembersChecked = True\r\n End If\r\nEnd Function\r\nPrivate bolMembersChecked As Boolean<\/pre>\n
\n
Set m_Form = cmd.Parent\r\nm_Form.OnCurrent = "[Event Procedure]"<\/pre>\n
Private Sub m_Form_Current()\r\n CheckMembers\r\n ActivateControls\r\nEnd Sub<\/pre>\n
Private Sub ActivateControls()\r\n If Not m_Up Is Nothing Then m_Up.Enabled = True\r\n If Not m_Down Is Nothing Then m_Down.Enabled = True\r\n If Not m_Top Is Nothing Then m_Top.Enabled = True\r\n If Not m_Bottom Is Nothing Then m_Bottom.Enabled = True\r\n If Not m_Datasheet Is Nothing Then\r\n If Not bolDelete Then\r\n Select Case m_Datasheet.Recordset.AbsolutePosition\r\n Case 0\r\n EnableUp\r\n Case m_Datasheet.Recordset.RecordCount - 1\r\n EnableDown\r\n Case m_Datasheet.Recordset.RecordCount\r\n EnableUp\r\n EnableDown\r\n Case -1\r\n EnableUp\r\n EnableDown\r\n End Select\r\n Else\r\n EnableUp\r\n EnableDown\r\n bolDelete = False\r\n End If\r\n If m_Datasheet.NewRecord Then\r\n EnableUp\r\n EnableDown\r\n End If\r\n End If\r\n If Not m_Listbox Is Nothing Then\r\n If m_Listbox.ListIndex = 0 Then\r\n EnableUp\r\n End If\r\n If m_Listbox.ListIndex = m_Listbox.ListCount - 1 + m_Listbox.ColumnHeads Then\r\n EnableDown\r\n End If\r\n If IsNull(m_Listbox) Then\r\n EnableUp\r\n EnableDown\r\n End If\r\n End If\r\nEnd Sub<\/pre>\n
Private Sub EnableUp()\r\n If Not m_Up Is Nothing Then m_Up.Enabled = False\r\n If Not m_Top Is Nothing Then m_Top.Enabled = False\r\nEnd Sub<\/pre>\n
Private Sub EnableDown()\r\n If Not m_Down Is Nothing Then m_Down.Enabled = False\r\n If Not m_Bottom Is Nothing Then m_Bottom.Enabled = False\r\nEnd Sub<\/pre>\n
Private Sub m_Datasheet_Current()\r\n ActivateControls\r\nEnd Sub<\/pre>\n
Private Sub m_Listbox_AfterUpdate()\r\n ActivateControls\r\nEnd Sub<\/pre>\n
Private Sub m_Datasheet_BeforeUpdate(Cancel As Integer)\r\n If m_Datasheet.NewRecord Then\r\n FillNewOrderID\r\n End If\r\nEnd Sub<\/pre>\n
Public Sub FillNewOrderID()\r\n Dim lngOrderMax As Long\r\n lngOrderMax = Nz(DMax(m_Orderfield, m_Table), 0)\r\n lngOrderMax = lngOrderMax + 1\r\n m_Datasheet(m_Orderfield).Value = lngOrderMax\r\nEnd Sub<\/pre>\n
Private bolDelete As Boolean<\/pre>\n
Private Sub m_Datasheet_Delete(Cancel As Integer)\r\n bolDelete = True\r\nEnd Sub<\/pre>\n
m_Datasheet.OnDelete = "[Event Procedure]"<\/pre>\n
Private Sub m_Top_Click()\r\n Dim lngTarget As Long\r\n Dim lngMove As Long\r\n If Not m_Datasheet Is Nothing Then\r\n lngIDTemp = m_Datasheet(m_PKField)\r\n End If\r\n lngMove = GetMove\r\n lngTarget = DMin(m_Orderfield, m_Table)\r\n InterchangeOrder lngTarget, lngMove\r\n RequeryControls lngTarget - lngMove + 1\r\nEnd Sub<\/pre>\n
Private lngIDTemp As Long<\/pre>\n
Private Function GetMove() As Long\r\n Dim lngMove As Long\r\n If Not m_Datasheet Is Nothing Then\r\n lngMove = m_Datasheet(m_Orderfield)\r\n End If\r\n If Not m_Listbox Is Nothing Then\r\n If Not IsNull(m_Listbox) Then\r\n lngMove = DLookup(m_Orderfield, m_Table, m_PKField & "=" & m_Listbox)\r\n End If\r\n End If\r\n GetMove = lngMove\r\nEnd Function<\/pre>\n
Private Sub RequeryControls(Optional lngMoved As Long)\r\n If Not m_Datasheet Is Nothing Then\r\n m_Datasheet.Requery\r\n m_Datasheet.Recordset.FindFirst m_PKField & "=" & lngIDTemp\r\n End If\r\n If Not m_Listbox Is Nothing Then\r\n m_Listbox.Requery\r\n End If\r\n ActivateControls\r\nEnd Sub<\/pre>\n
Private Sub m_Up_Click()\r\n Dim lngTarget As Long\r\n Dim lngMove As Long\r\n If Not m_Datasheet Is Nothing Then\r\n lngIDTemp = m_Datasheet(m_PKField)\r\n End If\r\n lngMove = GetMove\r\n lngTarget = DMax(m_Orderfield, m_Table, m_Orderfield & "<" & lngMove)\r\n InterchangeOrder lngTarget, lngMove\r\n RequeryControls lngMove - 1\r\nEnd Sub<\/pre>\n