<\/p>\n
Die Reihenfolge für die Anzeige von Daten legt man meist über Kriterien wie aufsteigend oder absteigend nach dem Alphabet eines Namens, nach Zeitangaben wie Uhrzeit oder Datum oder auch nach Zahlenwerten wie etwa Preisen oder Kilometerständen fest. Das sind Geschäftsdaten, die nicht primär der Sortierung dienen. Für manche Sortierkriterien gibt es allerdings keine passenden Felder: Hier müssen Sie selbst eines hinzufügen und für die richtige Reihenfolge Sorge tragen.<\/b><\/p>\n
Beispiele für ein solches Szenario gibt es genug. Nehmen wir ein typisches CMS (Content Management System) für eine Webanwendung, das einen Artikel aus mehreren Elementen wie normalen Absätzen, Bildern und vielleicht noch interaktiven Elementen zusammensetzt. Irgendwo muss man hier festlegen, in welcher Reihenfolge die Elemente auf der Webseite angezeigt werden sollen – unabhängig davon, in welcher Abfolge man diese angelegt hat. Oder schauen Sie sich das Beispiel aus dem Beitrag Verknüpfte Datenbanken updaten <\/b>(Shortlink 662) an: Die dort beschriebene Lösung führt beim Update eines Datenbankbackends eine oder mehrere SQL-Operationen aus, die natürlich nicht in willkürlicher Reihenfolge erfolgen können.<\/p>\n
Fazit: Auch hier muss die Reihenfolge in einem separaten Feld festgehalten werden. Und schließlich noch ein Beispiel: Wenn Sie Aufgaben mit einer Datenbank verwalten, vergeben Sie normalerweise eine Priorität. Da aber meist mehr Aufgaben als Prioritätsstufen vorhanden sind und man dennoch eine Abfolge für die Abarbeitung festlegen möchte, legt man auch hier ein zusätzliches Feld fest, das die Reihenfolge vorgibt.<\/p>\n
Wo ist aber nun der gravierende Unterschied zwischen Texten, Datums- oder Preisangaben und einem Reihenfolge-Feld, wie es in den zuvor beschriebenen Beispielen vorkommt Ganz einfach: Die Reihenfolge-Felder sind einzig und allein dafür da, die Reihenfolge festzulegen. In der Darstellung der Daten sind sie gar nicht sichtbar – außer durch die Reihenfolge, in der die Daten letztlich dargestellt werden.<\/p>\n
Reihenfolge-Feld<\/b><\/p>\n
Das manuelle Festlegen der Reihenfolge macht aber nur dort Sinn, wo die Menge der Datensätze deren Übersichtlichkeit nicht allzusehr einschränkt. Eine Tabelle mit 2.000.000 Datensätzen mit einem manuell einstellbaren Reihenfolge-Feld auszustatten ist nicht sinnvoll – uns ist jedenfalls kein Grund bekannt, warum man so etwas tun sollte. Für alle anderen Fälle verwenden Sie zum Einstellen der Reihenfolge ein Feld mit einem numerischen Datentyp, dessen Wertebereich von der Anzahl der zu erwartenden Daten abhängt. Damit Sie aber nicht doch irgendwann dummerweise in Fehler laufen, weil das Reihenfolge-Feld zu klein ausgelegt ist, verwenden wir, wie auch beim Primärschlüsselfeld üblich, den Datentyp Long<\/b>.<\/p>\n
Die Tabelle, die uns in diesem Beitrag begleiten soll und die Daten zum Anpassen der Reihenfolge liefern wird, sieht wie in Bild 1 aus und enthält neben dem Primärschlüsselfeld nur ein Feld namens Aufgabe <\/b>und das Feld ReihenfolgeID<\/b>.<\/p>\n
![\"pic001.png\"](\"..\/fileadmin\/_temp_\/2009_02\/Reihenfolge-web-images\/pic001_opt.jpeg\")
<\/p>\n
Bild 1: Beispieltabelle mit Reihenfolge-Feld<\/span><\/b><\/p>\n Reihenfolge ändern<\/b><\/p>\n Wenn Sie mal für interne Zwecke ein Reihenfolge-Feld benötigen und keine Lust haben, das ändern der Reihenfolge zu programmieren, können Sie das Reihenfolge-Feld natürlich auch genau wie die übrigen Felder anzeigen und die Reihenfolge von Hand eintragen – wenn Sie dann noch eine Sortierung für dieses Feld festlegen, reicht dies für rudimentäre Anforderungen schon aus.<\/p>\n Komfortabler ist es jedoch, wenn ein Formular Steuerelemente zum ändern der Reihenfolge vorsieht. Die wichtigsten Standardfunktionen sind folgende:<\/p>\n Je nachdem, welches Steuerelement man zur Anzeige der Daten verwendet, kann man auch noch komfortablere Methoden einsetzen:<\/p>\n Steuerelemente zum ändern der Reihenfolge<\/p>\n Je nachdem, welche Steuerelemente Sie zur Anzeige der Daten verwenden, sind die oben aufgeführten Optionen zum ändern der Reihenfolge mehr oder weniger aufwendig.<\/p>\n In der Datenblattansicht, der Endlosansicht oder im Listenfeld macht das ändern der Reihenfolge durch Verschieben eines Listenelements wenig Sinn, da man den Drag-and-Drop-Vorgang nur schlecht optisch darstellen kann. Dies funktioniert hingegen sehr gut im ListView<\/b>-Steuerelement, das von Haus aus Möglichkeiten für Drag and Drop mitbringt, dafür aber bezüglich der Datenbindung schlechter ausgestattet ist. Wir schauen uns im Folgenden aber alle Möglichkeiten an.<\/p>\n Reihenfolge-Algorithmen<\/b><\/p>\n Bevor wir loslegen, überlegen wir uns allerdings erstmal ein paar schicke Funktionen, die wir später dann nur unter die Haube der Benutzeroberfläche stecken müssen.<\/p>\n Die Voraussetzungen für die nachfolgend vorgestellten Funktionen sind eigentlich immer gleich: Es sollen die Daten einer Tabelle mit einem Primärschlüsselfeld nach einem Wert in einem Reihenfolge-Feld sortiert werden. Was sich unterscheiden kann, sind die Namen des Primärschlüsselfelds und des Reihenfolge-Felds. Damit unsere Funktionen ihren Dienst unabhängig von diesen Oberflächlichkeiten verrichten und Sie nicht für jede neue Datenbank, in der Sie diese Funktionen einsetzen möchten, im Code der Funktionen herumbasteln müssen, bauen wir uns einfach eine kleine Abfrage namens qryOrder<\/b>, die als Datenherkunft die zu sortierende Tabelle enthält – und davon auch nur das Primärschlüssel- und das Sortierfeld.<\/p>\n Und wie verhindert diese Abfrage nun, dass wir die im Code verwendeten Feldnamen je nach Zielanwendung und -tabelle ändern müssen Wir verwenden ganz einfach Aliasnamen für die Felder, die unabhängig von den Feldnamen immer gleich sind. Im Detail sieht das wie in Bild 2 aus – welche Geschäftsdaten sich in den anderen Feldern der zugrunde liegenden Tabelle befinden, ist für unsere Belange völlig uninteressant. Eine kleine Einschränkung gibt es jedoch: Das Primärschlüsselfeld muss einen numerischen Datentyp aufweisen. Wenn Sie einen String-Primärschlüssel verwenden, müssen Sie gegebenenfalls eine alternative Variante der hier vorgestellten Routinen erstellen.<\/p>\n Bild 2: Mit dieser Abfrage machen Sie alle zu sortierenden Tabellen gleich.<\/span><\/b><\/p>\n Reihenfolge-Feld füllen<\/b><\/p>\n Nicht immer ist man sich von vornherein im Klaren darüber, dass man für die Datensätze einer Tabelle ein zusätzliches Reihenfolge-Feld benötigt. Dementsprechend legt man vielleicht auch erstmal ein paar Datensätze an und fügt erst dann das Hilfsfeld für die Sortierung hinzu. Da dieses zu diesem Zeitpunkt noch leer ist, können Sie es entweder von Hand füllen oder diese Aufgabe durch eine kleine Routine erledigen lassen. Die Prozedur FillOrderID <\/b>durchläuft dazu eine Datensatzgruppe auf Basis der Abfrage qryOrder<\/b>, wobei es diese nach dem Feld OrderID <\/b>vorsortiert – damit können Sie diese Routine auch verwenden, um Lücken im Feld OrderID <\/b>zu schließen. Um eine Zählervariable zu sparen, erhält das Feld OrderID <\/b>eines jeden Datensatzes den Inhalt seiner Eigenschaft AbsolutePosition<\/b>, der bei 0 <\/b>beginnt und deshalb jeweils um eins erhöht wird.<\/p>\n Reihenfolgewert für neue Datensätze<\/b><\/p>\n Nachdem nun das Reihenfolge-Feld aller vorhandenen Datensätze gefüllt ist, müssen wir uns noch um neue Datensätze kümmern. Dafür legen wir am besten auch eine kleine Routine an, die Sie in der Ereignisprozedur, die beim Neuanlegen eines Datensatzes ausgelöst wird, aufrufen.<\/p>\n Als Parameter braucht diese Funktion nur den Primärschlüsselwert des neuen Datensatzes (s. Listing 1). Die Routine öffnet dann zunächst eine Datensatzgruppe, die nur den Datensatz mit dem höchsten Wert im Feld OrderID <\/b>enthält. Hier gibt es zwei Möglichkeiten:<\/p>\n Listing 1: Füllen der Reihenfolge-ID eines neuen Datensatzes<\/p>\n In beiden Fällen erhöht die Routine den Wert von lngOrderMax <\/b>um eins und schreibt diesen Wert dann in das Feld OrderID <\/b>des neuen Datensatzes.<\/p>\n Zwei Datensätze vertauschen<\/b><\/p>\n Vertauschen hört sich in Zusammenhang mit der Reihenfolge von Datensätzen erstmal gut an. Schließlich vertauscht man gern mal einen Datensatz mit den darüber oder darunterliegenden Nachbarn oder auch mit dem ersten oder letzten Datensatz … oder Nein! Es gibt wohl kaum einen Einsatzzweck, der das Vertauschen etwa des ersten und eines irgendwo in der Mitte liegenden Datenatzes erforderlich machen würde. Eigentlich möchten Sie ja einen oder mehrere Datensätze verschieben und nicht vertauschen.<\/p>\n Wenn Sie einen Datensatz an die Stelle eines unmittelbaren Nachbarn, also des vorherigen oder nachfolgenden Datensatzes verschieben, sieht das so aus, als ob die beiden Datensätze vertauscht werden. Tatsächlich ist hier aber vom ändern der Position eines Datensatzes, also vom Verschieben die Rede. Vergessen wir das Vertauschen also und sprechen fortan von Verschieben.<\/p>\n <\/p>\n Verschieben eines oder mehrerer Datensätze<\/b><\/p>\n Und wenn wir schon von Verschieben sprechen, dann reden wir auch gleich vom Verschieben nicht nur eines, sondern auch mehrerer Datensätze. Immerhin möchte man ja vielleicht auch mal ein paar Datensätze gleichzeitig in der Reihenfolge nach oben oder unten bewegen. Die Routine InterchangeOrder <\/b>aus Listing 2 erledigt dies alles anhand dreier Parameter, welche die folgenden Informationen abfragen sollen:<\/p>\n Listing 3: Prüfen des aktuellen Datensatzes und Aktivieren oder Deaktivieren der Schaltflächen zum Verschieben von Datensätzen<\/p>\n Wenn lngMoveLastOrderID<\/b> nicht übergeben würde, also nur ein Datensatz verschoben werden soll, stellt die Routine diesen Wert zunächst auf den von lngMoveFirstOrderID <\/b>ein – das ist aus technischen Gründen wichtig, damit man die beiden Fälle gleich behandeln kann ("Verschiebe Datensatz 1 bis 3 hinter 5" funktioniert dann genauso wie "Verschiebe Datensatz 1 hinter 5"). Die Variable intCountMove <\/b>wird dann mit der Anzahl der zu verschiebenden Datensätze gefüllt.<\/p>\n Anschließend folgt die wichtigste Fallunterscheidung dieser Prozedur: Sollen Datensätze nach vorne oder hinten verschoben werden In der Routine wird diese Frage so beantwortet: Ist die ID des ersten zu verschiebenden Datensatzes größer als die des Zieldatensatzes, dann geht es nach vorne (siehe Bild 3), sonst nach hinten (siehe Bild 4).<\/p>\n Bild 3: Verschieben von Datensätzen nach vorne vor einen anderen Datensatz<\/span><\/b><\/p>\n Wenn der Zieldatensatz vor dem ersten zu verschiebenden Datensatz liegt, öffnet die Routine eine Datensatzgruppe, die alle Datensätze vom Zieldatensatz bis zum letzten zu verschiebenden Datensatz enthält (in Bild 3 wären das die Datensätze 2 bis 5). Anschließend durchläuft die Routine alle Datensätze dieser Datensatzgruppe und führt eine von zwei Aktionen an ihnen durch:<\/p>\n Es kann auch sein, dass einer oder mehrere Datensätze nach hinten verschoben werden sollen, wie es in Bild 4 der Fall ist. Dies wird im zweiten Teil der äußeren If…Then<\/b>-Bedingung berücksichtigt. Auch hier erzeugt die Routine eine Datensatzgruppe, die alle betroffenen Datensätze enthält – in Bild 4 sind dies die Datensätze 2 bis 4.<\/p>\n Bild 4: Verschieben eines Datensatzes nach hinten hinter einen anderen Datensatz<\/span><\/b><\/p>\n Solange die Do While<\/b>-Schleife Datensätze durchläuft, die verschoben werden sollen (hier Nummer 2), wird deren Reihenfolge-ID um einen Wert erhöht, welcher der Anzahl der Elemente zwischen dem letzten zu verschiebenden und dem Zieldatensatz entspricht.<\/p>\n Die Reihenfolge-ID aller weiteren (hier 3 und 4) wird um die Anzahl der zu verschiebenden Datensätze vermindert (hier 2). Das war's – mit dieser Routine können Sie alle möglichen Verschiebungen auf den Datensätzen der Tabelle abbilden.<\/p>\n Sortierung im Unterformular in der Datenblattansicht anpassen<\/b><\/p>\n Schauen wir uns nun an, wie Sie diese Routine in der Praxis einsetzen können. Das erste Beispiel ist ein Hauptformular, dessen Unterformular die Datensätze unserer Beispieltabelle tblAufgaben <\/b>anzeigt.<\/p>\n Wir brauchen nun vier Steuerelemente, die ausgehend vom aktuell markierten Steuerelement die folgenden Aktionen aufrufen:<\/p>\n Das Beispielformular haben wir bewusst einfach gehalten. Es besteht aus dem Hauptformular frmDatenblatt <\/b>und dem Unterformular sfmDatenblatt <\/b>sowie den vier Schaltflächen cmdTop<\/b>, cmdUp<\/b>, cmdDown <\/b>und cmdBottom <\/b>und sieht im Entwurf wie in Bild 5 und in der Formularansicht wie in Bild 6 aus. Die Schaltflächen sind mit entsprechenden Ereignisprozeduren ausgestattet. Die Schaltfläche cmdUp <\/b>beispielsweise löst beim Mausklick die folgende Routine aus. Sie schreibt einfach das Feld ReihenfolgeID <\/b>des aktuell markierten Datensatzes in die Variable lngMove <\/b>und ermittelt dann mit der DMin<\/b>-Domänenfunktion den Wert des Feldes ReihenfolgeID <\/b>des ersten Datensatzes der Tabelle tblAufgaben<\/b>.<\/p>\n Bild 5: Das Formular zum Verschieben von Datensätzen in der Entwurfs- …<\/span><\/b><\/p>\n Bild 6: … und in der Formularansicht<\/span><\/b><\/p>\n Der Aufruf der Routine InterchangeOrder <\/b>sorgt dann dafür, dass die Werte des Feldes ReihenfolgeID <\/b>der betroffenen Datensätze in der zugrunde liegenden Tabelle geändert werden. Die Requery<\/b>-Methode in der letzten Zeile aktualisiert dann die Anzeige der Daten im Unterformular. Beim Verschieben des aktuellen Datensatzes um eine Position nach oben kommt die Schaltfläche cmdUp <\/b>ins Spiel. Die dadurch ausgelöste Prozedur unterscheidet sich nur unwesentlich von der zuvor beschriebenen, indem sie nicht den Wert des Feldes ReihenfolgeID <\/b>des ersten Datensatzes der Datenherkunft, sondern einfach vom Wert des aktuellen Datensatzes den Wert 1 <\/b>abzieht.<\/p>\n Die beiden übrigen Prozeduren verhalten sich analog.<\/p>\n Leider zeigt sich das Unterformular in der Datenblattansicht nicht besonders kooperativ, was das Verhalten beim Requery angeht: Es springt anschließend nämlich immer zum ersten Datensatz der Datenherkunft. Um dies benutzerfreundlicher zu gestalten, können Sie die im Beitrag Kein Datensatz- und Positionswechsel bei Requery <\/b>(Shortlink 602) vorgestellten Techniken verwenden.<\/p>\n Schaltflächen am Anfang und am Ende deaktivieren<\/b><\/p>\n Wenn der Datensatzzeiger im Unterformular auf dem ersten oder letzten Datensatz steht, sollten die Schaltflächen zum Springen auf den vorherigen beziehungsweise nachfolgenden Datensatz deaktiviert sein, weil deren Aufruf sonst einen Fehler auslösen würde. Dies erledigt die Routine aus Listing 3, die bei jedem Datensatzwechsel im Unterformular ausgelöst wird.<\/p>\n Listing 4: Füllen des ListView-Steuerelements<\/p>\n Löschen von Datensätzen<\/b><\/p>\n Die bisher vorgestellten Routinen sind bislang stillschweigend davon ausgegangen, dass die vorhandenen Datensätze im Feld ReihenfolgeID <\/b>immer lückenlos durchnummeriert sind. Damit das auch so bleibt, wenn mal ein Datensatz gelöscht wird, müssen Sie die Lücke gleich nach dem Löschen wieder schließen. Abhängig von der Anzahl der betroffenen Datensätze können Sie dies in einem Rutsch erledigen, indem Sie die weiter oben vorgestellte Prozedur FillOrderID <\/b>aufrufen. Im Falle unseres Unterformulars füllen Sie die Prozedur, die durch das Ereignis Beim Löschen <\/b>ausgelöst wird, mit den folgenden beiden Anweisungen:<\/p>\n Sortierung im Listenfeld anpassen<\/b><\/p>\n Das Listenfeld ist im Vergleich zu einem Unterformular in der Datenblattsicht insofern pflegeleichter, als dass ein Requery die aktuelle Ansicht kaum sichtbar beeinflusst. Alles weitere verläuft im Listenfeld prinzipiell genau so wie beim Unterformular, weshalb wir das in Bild 7 dargestellte Listenfeld mit den entsprechenden Schaltflächen zum Verschieben des aktuell markierten Eintrags nicht detaillierter besprechen und direkt zum wesentlich spannenderen ListView<\/b>-Steuerelement übergehen.<\/p>\n Bild 7: Reihenfolge von Datensätzen im Listenfeld einstellen<\/span><\/b><\/p>\n Sortierung im ListView-Steuerelement anpassen<\/b><\/p>\n In diesem Zusammenhang müssen Sie vorab eine Sache mit sich selbst und den Anforderungen der Anwendung ausmachen: Man kann einen Datensatz auch in einem ListView-Steuerelement nur auf einen anderen Datensatz und in den Zwischenraum zwischen zwei Datensätzen ziehen, was schon wichtig wäre, um die gewünschte Position zu verdeutlichen. Im Beispielformular frmListView <\/b>(siehe Bild 8) geschieht dies nun so, wie es uns am intuitivsten vorkam: Datensätze, die nach vorne gezogen werden, sollen vor dem Zieldatensatz eingefügt werden, und solche, die nach hinten gezogen werden, sollen hinter dem Zieldatensatz landen.<\/p>\n Bild 8: Einstellen der Reihenfolge per Drag and Drop im ListView-Steuerelement<\/span><\/b><\/p>\n Erstmal müssen wir das ListView mit den gewünschten Daten füllen, was die Routine ListViewFuellen <\/b>erledigt, die durch die Form_Load<\/b>-Ereignisprozedur aufgerufen wird – aber erst, nachdem diese über die Routine FillOrderID <\/b>die Werte des Feldes ReihenfolgeID <\/b>aktualisiert hat (s. Listing 4).<\/p>\n Listing 6: Markieren des jeweils überfahrenen Elements<\/p>\n Reihenfolge festlegen per Drag and Drop<\/b><\/p>\n Der Grund für den Einsatz des ListView-Steuerelements ist ja, dass Sie mit diesem auch Drag-and-Drop-Operationen durchführen können. Oft ist es viel weniger mühselig, Daten auf diese Weise zu sortieren, als dies mit entsprechenden Schaltflächen wie mit den bisherigen Lösungen zu erledigen.<\/p>\n Der Drag-and-Drop-Vorgang startet nach dem Markieren von einem oder auch mehreren Elementen des ListView-Steuerelements und endet recht schnell, wenn die Routine aus Listing 5 feststellt, dass keine zusammenhängenden Elemente markiert wurden. Anderenfalls kann es aber losgehen: Die Anweisungen aus Listing 5 durchlaufen alle Listenelemente und schreiben den Index des ersten und des letzten in das Data-Objekt, das von der Ereignisprozedur OLEDragDrop <\/b>später wieder ausgelesen werden kann.<\/p>\n Die Routine aus Listing 6 stellt sicher, dass beim Ziehen der zu verschiebenden Elemente jeweils das überfahrene Element markiert wird, damit der Benutzer weiß, wo der Packen landet, wenn er jetzt loslässt.<\/p>\n Dies geschieht dann in Listing 7, wo zwei wesentliche Operationen stattfinden. Die einfachere (ganz am Ende) ruft einfach die bereits bekannte Routine InterchangeOrder <\/b>mit den entsprechenden Parametern auf, damit die änderungen in der zugrunde liegenden Tabelle gespeichert werden. Die andere aktualisiert den Inhalt des ListView-Steuerelements. Man könnte zwar auch einfach alle Elemente löschen und neu einlesen, aber wir wollen es ja richtig und ohne Seiteneffekte wie das Verschlagen des aktuellen Elements erledigen.<\/p>\n Was die Routine hierzu beiträgt, ist Folgendes: Sie liest zunächst aus dem Objekt Data <\/b>die Indexwerte des ersten und des letzten verschobenen Elements aus und ermittelt zusätzlich den Index des Elements, auf das der Benutzer die zu verschiebenden Elemente gezogen hat. In diesem Zusammenhang sei darauf verwiesen, dass der Index der ListView-Elemente den Werten des Feldes ReihenfolgeID <\/b>der Tabelle tblAufgaben <\/b>entspricht.<\/p>\n Dann öffnet sie eine Datensatzgruppe, die alle Datensätze der Tabelle tblAufgaben <\/b>beinhaltet, die durch die übergebenen Indexwerte eingeschlossen werden – aber in absteigender Reihenfolge bezogen auf das Feld ReihenfolgeID<\/b>. Die Datensätze dieser Datensatzgruppe durchläuft sie im Anschluss und löscht jeweils das Element aus dem ListView<\/b>-Steuerelement, welches dem aktuellen Datensatz entspricht. Die Elemente müssen natürlich auch wieder angelegt werden, was eine Anweisung später geschieht.<\/p>\n Dort wird das aktuelle Element mit der Add-Methode zum ListView hinzugefügt, allerdings nicht unter Berücksichtigung der im Datensatz gespeicherten ReihenfolgeID, sondern mit dem Index des Elements, auf das der Benutzer die zu verschiebenden Elemente gezogen hat. Warum das Nun: Legt man im ListView-Steuerelement ein Element mit dem Index eines vorhandenen Elements an, wird dieses genau wie alle folgenden Elemente nach hinten verschoben. Und deshalb werden die zu verschiebenden Elemente auch in umgekehrter Reihenfolge abgearbeitet: weil die ersten die letzten sein werden und die Reihenfolge somit wieder stimmt.<\/p>\n Zusammenfassung und Ausblick<\/p>\n Wenn Sie einmal eine Sammlung von Techniken für das Sortieren von Datensätzen nach einem speziell dafür vorgesehenen Sortierfeld besitzen, brauchen Sie sich um dieses Thema nicht mehr viele Gedanken zu machen. Wichtig ist, dass Sie durchgehend darauf achten, die Werte des betroffenen Feldes – hier ReihenfolgeID <\/b>– immer lückenlos zu halten. Dazu können Sie bei Gelegenheit eine Aktualisierung der Werte dieses Feldes durchführen, was bei der zu erwartenden Anzahl der Datensätze einer Tabelle, die Sie manuell und individuell sortieren möchten, vertretbar ist. Also: Sortieren Sie!<\/p>\n Listing 2: Die Universalfunktion zum Verschieben von Datensätzen anhand eines Reihenfolge-Felds<\/p>\n Listing 5: Start des Drag-and-Drop-Vorgangs<\/p>\n Listing 7: Ende des Drag-and-Drop-Vorgangs und Anpassen der Reihenfolge<\/p>\n Enthaltene Beispieldateien:<\/p>\n Reihenfolge.mdb<\/p>\n\n
\n
![\"pic002.png\"](\"..\/fileadmin\/_temp_\/2009_02\/Reihenfolge-web-images\/pic002_opt.jpeg\")
<\/p>\nPublic Sub FillOrderID()\r\nDim db As DAO.Database\r\nDim rst As DAO.Recordset\r\nSet db = CurrentDb\r\nSet rst = db.OpenRecordset("SELECT * FROM µ\r\nqryOrder ORDER BY OrderID", dbOpenDynaset)\r\nDo While Not rst.EOF\r\n rst.Edit\r\n rst!OrderID = rst.AbsolutePosition + 1\r\n rst.Update\r\n rst.MoveNext\r\nLoop\r\nEnd Sub<\/pre>\nPublic Sub FillNewOrderID(lngPKID As Long)\r\nDim db As DAO.Database\r\nDim rst As DAO.Recordset\r\nDim lngOrderMax As Long\r\nSet db = CurrentDb\r\nSet rst = db.OpenRecordset("SELECT TOP 1 OrderID " _\r\n& "FROM qryOrder WHERE OrderID IS NOT NULL " _\r\n& "ORDER BY OrderID DESC")\r\nIf Not rst.EOF Then\r\n lngOrderMax = rst.Fields(0)\r\nEnd If\r\nlngOrderMax = lngOrderMax + 1\r\ndb.Execute "UPDATE qryORDER " _\r\n& "SET OrderID = " & lngOrderMax _\r\n& " WHERE PKID = " & lngPKID, dbFailOnError\r\nSet db = Nothing\r\nEnd Sub<\/pre>\n\n
Private Sub Form_Current()\r\n Dim bolFirst As Boolean\r\n Dim bolLast As Boolean\r\n Dim bolNew As Boolean\r\n bolFirst = Me.CurrentRecord = 1\r\n bolLast = (Me.CurrentRecord = _\r\n Me.RecordsetClone.RecordCount)\r\n bolNew = Me.NewRecord\r\n Me.Parent.cmdOK.SetFocus\r\n Me.Parent.cmdUp.Enabled = Not (bolFirst Or bolNew)\r\n Me.Parent.cmdTop.Enabled = Not (bolFirst Or bolNew)\r\n Me.RecordsetClone.MoveLast\r\n Me.Parent.cmdDown.Enabled = Not (bolLast Or bolNew)\r\n Me.Parent.cmdBottom.Enabled = Not (bolLast Or bolNew)\r\n End Sub<\/pre>\n
\n
![\"NachOben.emf\"](\"..\/fileadmin\/_temp_\/2009_02\/Reihenfolge-web-images\/NachOben_opt.jpeg\")
<\/p>\n\n
![\"NachUnten.emf\"](\"..\/fileadmin\/_temp_\/2009_02\/Reihenfolge-web-images\/NachUnten_opt.jpeg\")
<\/p>\n\n
![\"pic003.png\"](\"..\/fileadmin\/_temp_\/2009_02\/Reihenfolge-web-images\/pic003_opt.jpeg\")
<\/p>\n![\"pic004.png\"](\"..\/fileadmin\/_temp_\/2009_02\/Reihenfolge-web-images\/pic004_opt.jpeg\")
<\/p>\nPrivate Sub cmdTop_Click()\r\nDim lngTarget As Long\r\nDim lngMove As Long\r\nlngMove = Me.sfmDatenblatt.Form.ReihenfolgeID\r\nlngTarget = DMin("ReihenfolgeID", \r\n"tblAufgaben")\r\nInterchangeOrder lngTarget, lngMove\r\nMe.sfmDatenblatt.Form.Requery\r\nEnd Sub<\/pre>\nPrivate Sub cmdUp_Click()\r\nDim lngTarget As Long\r\nDim lngMove As Long\r\nlngMove = Me.sfmDatenblatt.Form.ReihenfolgeID\r\nlngTarget = lngMove - 1\r\nInterchangeOrder lngTarget, lngMove\r\nMe.sfmDatenblatt.Form.Requery\r\nEnd Sub<\/pre>\n
Dim WithEvents objAufgaben As MSComctlLib.ListView\r\nPrivate Sub Form_Load()\r\n Set objAufgaben = Me.lvwAufgaben.Object\r\n FillOrderID\r\n ListViewFuellen\r\n End Sub\r\nPrivate Sub ListViewFuellen()\r\n Dim db As DAO.Database\r\n Dim rst As DAO.Recordset\r\n Dim objListitem As MSComctlLib.ListItem\r\n Set db = CurrentDb\r\n Set rst = db.OpenRecordset("SELECT * FROM tblAufgaben ORDER BY ReihenfolgeID", dbOpenDynaset)\r\n objAufgaben.ListItems.Clear\r\n Do While Not rst.EOF\r\n Set objListitem = objAufgaben.ListItems.Add(rst!ReihenfolgeID, "a" & rst!ID, rst!Aufgabe)\r\n objListitem.ListSubItems.Add , "a" & rst!ID, rst!ReihenfolgeID\r\n rst.MoveNext\r\n Loop\r\n End Sub<\/pre>\nPrivate Sub Form_Delete(Cancel As Integer)\r\nFillOrderID\r\nEnd Sub<\/pre>\n
![\"pic005.png\"](\"..\/fileadmin\/_temp_\/2009_02\/Reihenfolge-web-images\/pic005_opt.jpeg\")
<\/p>\n![\"pic006.png\"](\"..\/fileadmin\/_temp_\/2009_02\/Reihenfolge-web-images\/pic006_opt.jpeg\")
<\/p>\nPrivate Sub objAufgaben_OLEDragOver(Data As MSComctlLib.DataObject, Effect As Long, Button As Integer, _\r\n Shift As Integer, x As Single, y As Single, State As Integer)\r\n Set objAufgaben.DropHighlight = objAufgaben.HitTest(x, y)\r\n objAufgaben.HotTracking = True\r\n End Sub<\/pre>\n
Public Sub InterchangeOrder(lngTargetOrderID As Long, lngMoveFirstOrderID As Long, _\r\nOptional lngMoveLastOrderID As Long)\r\nDim db As DAO.Database\r\nDim rst As DAO.Recordset\r\nDim intCountMove As Integer\r\nSet db = CurrentDb\r\nIf lngMoveLastOrderID = 0 Then\r\nlngMoveLastOrderID = lngMoveFirstOrderID\r\nEnd If\r\nintCountMove = lngMoveLastOrderID - lngMoveFirstOrderID + 1\r\nIf lngTargetOrderID < lngMoveFirstOrderID Then\r\nSet rst = db.OpenRecordset("SELECT * FROM qryOrder WHERE OrderID >= " & lngTargetOrderID _\r\n& " AND OrderID <= " & lngMoveLastOrderID & " ORDER BY OrderID", dbOpenDynaset)\r\nDo While Not rst.EOF\r\n rst.Edit\r\n If rst!OrderID < lngMoveFirstOrderID Then\r\n rst!OrderID = rst!OrderID + intCountMove\r\n Else\r\n rst!OrderID = rst!OrderID - (lngMoveFirstOrderID - lngTargetOrderID)\r\n End If\r\n rst.Update\r\n rst.MoveNext\r\nLoop\r\nElse\r\nSet rst = db.OpenRecordset("SELECT * FROM qryOrder WHERE OrderID >= " _\r\n& lngMoveFirstOrderID & " AND OrderID <= " & lngTargetOrderID _\r\n& " ORDER BY OrderID", dbOpenDynaset)\r\nDo While Not rst.EOF\r\n rst.Edit\r\n If rst!OrderID <= lngMoveLastOrderID Then\r\n rst!OrderID = rst!OrderID + (lngTargetOrderID - lngMoveLastOrderID)\r\n Else\r\n rst!OrderID = rst!OrderID - (lngMoveLastOrderID - lngMoveFirstOrderID + 1)\r\n End If\r\n rst.Update\r\n rst.MoveNext\r\nLoop\r\nEnd If\r\nEnd Sub<\/pre>\nPrivate Sub objAufgaben_OLEStartDrag(Data As MSComctlLib.DataObject, AllowedEffects As Long)\r\nDim objListitem As MSComctlLib.ListItem\r\nDim strData As String\r\nDim lngFirstOrderID As Long\r\nDim lngLastOrderID As Long\r\nDim intCountSelected As Integer\r\nFor Each objListitem In objAufgaben.ListItems\r\nIf objListitem.Selected Then\r\n intCountSelected = intCountSelected + 1\r\n If lngFirstOrderID = 0 Then lngFirstOrderID = objListitem.Index\r\n lngLastOrderID = objListitem.Index\r\n Data.SetData lngFirstOrderID & "|" & lngLastOrderID\r\nEnd If\r\nNext objListitem\r\nIf lngLastOrderID - lngFirstOrderID + 1 > intCountSelected Then\r\nMsgBox "Sie können nur zusammenhängende Elemente verschieben."\r\nEnd If\r\nEnd Sub<\/pre>\n
Private Sub objAufgaben_OLEDragDrop(Data As MSComctlLib.DataObject, Effect As Long, Button As Integer, _\r\nShift As Integer, x As Single, y As Single)\r\nDim strSource As String\r\nDim lngFirstOrderID As Long\r\nDim lngLastOrderID As Long\r\nDim lngTargetOrderID As Long\r\nDim objListitem As MSComctlLib.ListItem\r\nDim db As DAO.Database\r\nDim rst As DAO.Recordset\r\nSet db = CurrentDb\r\nstrSource = Data.GetData(ccCFText)\r\nlngFirstOrderID = Split(strSource, "|")(0)\r\nlngLastOrderID = Split(strSource, "|")(1)\r\nSet rst = db.OpenRecordset("SELECT * FROM tblAufgaben WHERE ReihenfolgeID >= " & lngFirstOrderID _\r\n& " AND ReihenfolgeID <= " & lngLastOrderID & " ORDER BY ReihenfolgeID DESC", dbOpenDynaset)\r\nlngTargetOrderID = objAufgaben.HitTest(x, y).Index\r\nDo While Not rst.EOF\r\nobjAufgaben.ListItems.Remove "a" & rst!ID\r\nSet objListitem = objAufgaben.ListItems.Add(lngTargetOrderID, "a" & rst!ID, rst!Aufgabe)\r\nobjListitem.ListSubItems.Add , "a" & rst!ID, rst!ReihenfolgeID\r\nrst.MoveNext\r\nLoop\r\nInterchangeOrder lngTargetOrderID, lngFirstOrderID, lngLastOrderID\r\nSet objAufgaben.DropHighlight = Nothing\r\nSet objAufgaben.SelectedItem = Nothing\r\nEnd Sub<\/pre>\nDownloads zu diesem Beitrag<\/h3>\n