<\/p>\n
Wenn Sie mit ListView- und TreeView-Steuerelementen arbeiten, sind Drag-and-Drop-Operationen ein tolles Hilfsmittel, um Daten zwischen den Steuerelementen hin- und herzuschieben. In der Anwendung aiuTimeplanner gibt es gleich zwei ListView- und ein TreeView-Steuerelement – genügend Möglichkeiten also, um Drag and Drop einmal anhand eines Praxisbeispiels zu demonstrieren. Dabei sollen Aufgaben aus dem TreeView in beide ListViews verschoben werden sowie von ListView zu ListView – und das Verschieben und Kopieren von Einträgen innerhalb eines ListView-Steuerelements ist ebenfalls gefragt.<\/b><\/p>\n
Das Hin- und Herschieben von Elementen zwischen verschiedenen ListView- und TreeView-Einträgen ist prinzipiell nicht schwierig. Beim Start des Drag-and-Drop-Vorgangs wird immer das OLEStartDrag<\/b>-Ereignis ausgelöst, dem Sie mit dem Parameter Data<\/b> Informationen über die zu verschiebenden Daten mitgeben. Beim Überfahren des Drop-Ziels und beim Fallenlassen werden die beiden Ereignisprozeduren OLEDragOver <\/b>und OLEDragDrop <\/b>ausgelöst, denen Sie wiederum über den gleichen Parameter die beim Start übergebenen Daten entnehmen können.<\/p>\n
Sie starten also beispielsweise von einem ListView-Steuerelement einen Drag-and-Drop-Vorgang und speisen den Key<\/b>-Wert des gezogenen Elements in den Parameter Data <\/b>ein, beispielsweise t123<\/b>. Dann sollte t <\/b>einen Hinweis auf das Steuerelement geben, von dem aus der Vorgang gestartet wurde, und 123 <\/b>entspricht dem Primärschlüsselwert des Datensatzes, der per Drag and Drop bewegt werden soll.<\/p>\n
Im Beispiel, das im Beitrag Tagesablauf verwalten mit dem aiuTimeplanner <\/b>(www.access-im-unternehmen.de\/839<\/b>) genauer erläutert wird, gibt es drei Steuerelemente, die Drag-and-Drop-Operationen unterstützen:<\/p>\n Es gibt gleich eine ganze Reihe möglicher Drag-and-Drop-Operationen, die durch die Pfeile in Bild 1 verdeutlicht werden:<\/p>\n Bild 1: Mögliche Drag-and-Drop-Vorgänge in der Beispielanwendung<\/span><\/b><\/p>\n Gezogene Elemente identifizieren<\/b><\/p>\n Die Elemente können über den Wert der Eigenschaft Key <\/b>dem jeweiligen Steuerelement zugeordnet werden, also beispielsweise d <\/b>für lvwDailyTasks<\/b>, t <\/b>für tvwTasks <\/b>und p <\/b>für lvwTimeplan<\/b>. So kann man über den Wert des Parameters Data <\/b>jeweils am ersten Buchstaben erkennen, von welchem Steuerelement aus der Drag-and-Drop-Vorgang gestartet wurde, die folgenden Zahlen liefern die ID des Elements aus der jeweiligen Tabelle.<\/p>\n Dies wird natürlich etwas schwieriger, wenn Sie etwa in einem TreeView-Steuerelement die Daten aus mehreren Tabellen speichern und beispielsweise Kunden mit dem Präfix k <\/b>und Artikel mit dem Präfix a <\/b>versehen.<\/p>\n Dies erhöht jedoch nur die Anzahl der möglichen Kombinationen und damit die verschiedenen Arten, einen Drag-and-Drop-Vorgang anhand von Quelle und Ziel zu verarbeiten. Sie können nach wie vor mit einem Präfix-Buchstaben arbeiten, der die Art der Daten beschreibt, und daran den Primärschlüsselwert des entsprechenden Elements anhängen.<\/p>\n Starten eines Drag-and-Drop-Vorgangs<\/p>\n Der Start eines Drag-and-Drop-Vorgangs beginnt immer mit dem Herunterdrücken der Maustaste auf einem Element eines ListView- oder TreeView-Steuerelements und dem Bewegen des Mauszeigers bei gedrückter Maustaste. Dies ist der Moment, in dem Sie Informationen über das gezogene Element aufnehmen und speichern müssen.<\/p>\n Das passende Ereignis lautet OLEStartDrag<\/b> und kann über die beiden Kombinationsfelder des Klassenmoduls des Formulars hinzugefügt werden (s. Bild 2).<\/p>\n Bild 2: Hinzufügen des OLEStartDrag-Ereignisses<\/span><\/b><\/p>\n Damit dieses Ereignis und die beiden im Verlauf dieses Beitrags vorgestellten Ereignisse nach Wunsch ausgelöst werden, müssen Sie für die entsprechenden Objektvariablen außerdem noch je zwei Eigenschaften einstellen – dies geschieht in Konfigurationsprozeduren, die im Beitrag Tagesablauf verwalten mit aiuTimeplanner <\/b>(www.access-im-unternehmen.de\/839<\/b>) beschrieben werden:<\/p>\n Die drei Ereignisprozeduren objTasks_OLEStartDrag<\/b>, objDailyTasks_OLEStartDrag <\/b>und objTimeplan_OLEStartDrag <\/b>werden dann wie in Listing 1<\/a><\/span> angelegt und wie die Prozedur objTasks_OLEStartDrag <\/b>gefüllt.<\/p>\n Listing 1: Diese Prozeduren werden beim Starten eines Drag-and-Drop-Vorgangs ausgelöst.<\/p>\n Die Prozeduren ermitteln jeweils das beim Start des Drag-Vorgangs markierte Element. Ist kein Element markiert, wird die Prozedur beendet. Anderenfalls wird der Parameter Data <\/b>erst geleert und dann mit dem Wert der Key<\/b>-Eigenschaft des betroffenen Elements gefüllt, also beispielsweise t123 <\/b>beim Ziehen eines Elements des Aufgabenbaums, d234 <\/b>beim Ziehen eines Elements der Tagesliste oder p345 <\/b>beim Ziehen eines Elements der Tätigkeitenliste.<\/p>\n Damit enthält der Parameter Data <\/b>genaue Informationen über den Ursprung der Drag-and-Drop-Operation und über den Primärschlüsselwert des gezogenen Elements.<\/p>\n Ziel beim Überfahren markieren<\/b><\/p>\n Damit der Benutzer erkennt, wo er ein Element fallenlassen kann und wo nicht, markieren wir potenzielle Ziele beim Überfahren. Dies erledigen die Ereignisprozeduren objTasks_OLEDragOver<\/b>, objDailyTasks_OLEDragOver <\/b>und objTimeplan_OLEDragOver<\/b>. Die Prozeduren sind für alle drei Steuerelemente sehr ähnlich aufgebaut, sodass wir nur eines in Listing 2<\/a><\/span> komplett abbilden.<\/p>\n Listing 2: Ereignisprozedur beim Überfahren des Zielelements<\/p>\n Dort wird zunächst das Format des gezogenen Elements geprüft, das den Wert ccCFText <\/b>aufweisen sollte – anderenfalls wird die Prozedur abgebrochen. Ist das Format korrekt, liest die Prozedur den Inhalt des Parameters Data <\/b>in eine String<\/b>-Variable namens strData <\/b>ein, also beispielsweise t123<\/b>.<\/p>\n Daraus entnimmt sie den ersten Buchstaben, der einen Hinweis auf die Herkunft des gezogenen Elements liefert. t <\/b>steht wie erwähnt für objTasks<\/b>, p <\/b>für objTimeplan <\/b>und d <\/b>für objDailyTasks<\/b>. Anhand dieses Wertes entscheidet die Prozedur, ob ein Element beim Überfahren als Ziel markiert werden soll.<\/p>\n Dies geschieht, indem mit der HitTest<\/b>-Funktion des Zielsteuerelements ein Verweis auf das Zielelement ermittelt wird.<\/p>\n Dieser wird anschließend der DropHighlight<\/b>-Eigenschaft des jeweiligen Steuerelements zugeordnet, was dazu führt, dass das Zielelement durch einen blauen Hintergrund markiert wird.<\/p>\n Für das Objekt objDailyTasks <\/b>sieht die Prozedur genauso aus wie die für objTasks<\/b>. Die Prozedur objTimeplan_OLEDragOver <\/b>enthält jedoch eine andere Bedingung zur Prüfung des Datentyps des gezogenen Elements:<\/p>\n Das bedeutet, dass ein Element nicht nur beim Ziehen einer Aufgabe aus dem TreeView-Objekt objTasks <\/b>als Ziel angeboten wird, sondern auch beim Ziehen von Elementen aus der Tagesliste und aus der Tätigkeitsübersicht selbst.<\/p>\n <\/p>\n An dieser Stelle könnten Sie noch verschiedene Symbole einblenden, die einen Hinweis auf die geplante Aktion liefern. Dazu stellen Sie den Parameter Effect<\/b> auf einen der folgenden Werte ein:<\/p>\n Element fallenlassen<\/b><\/p>\n Kommen wir zu den wirklich interessanten Aktionen – den Datenoperationen und den änderungen der Darstellung beim Fallenlassen eines Elements auf einem erlaubten Ziel.<\/p>\n Als Erstes sehen wir uns das Fallenlassen eines Elements auf dem TreeView-Objekt des Formulars an. Dies löst die Ereignisprozedur objTasks_OLEDragDrop <\/b>aus (s. Listing 3<\/a><\/span>). Diese Prozedur enthält ebenfalls einen Parameter namens Data<\/b>, der den Kennbuchstaben für den entsprechenden Elementtyp und den Primärschlüsselwert liefert.<\/p>\n Listing 3: Beenden des Drag-and-Drop-Vorgangs<\/p>\n Dieser Wert wird zunächst ausgelesen. Die einzelnen Bestandteile landen in den beiden Variablen strDatatype <\/b>und lngKeyDrag<\/b>. Das TreeView-Steuerelement kann nur Elemente verarbeiten, die auch von dort aus gezogen wurden. Der Wert der Variablen strDatatype <\/b>muss also t <\/b>lauten, anderenfalls geschieht nichts.<\/p>\n Danach unterscheidet die Prozedur zwei Fälle, die davon abhängen, ob die Variable objNodeDrop <\/b>einen Wert enthält oder nicht. Die Variable wird mit einem Verweis auf das TreeView-Element gefüllt, auf dem das Drag-and-Drop-Element fallengelassen wurde. Hat der Benutzer also ein Element auf ein anderes Element gezogen, wird dieses mit objNodeDrop <\/b>referenziert. Hat er hingegen ein Element an eine freie Stelle innerhalb des TreeView-Steuerelements gezogen, bleibt objNodeDrop <\/b>leer.<\/p>\n In diesem Fall wird das gezogene Element gelöscht. Es ist nur noch offen, ob es direkt gelöscht werden soll oder ob zuvor noch eine Rückfrage erfolgen soll. Wenn der Benutzer beim Ziehen des Elements in den leeren Raum die Umschalttaste gedrückt hat, wird das Element direkt gelöscht, ohne Betätigen einer Taste erscheint noch eine Rückfrage.<\/p>\n Damit die dadurch aufgerufene Prozedur AufgabeLoeschen <\/b>je nach Tastenkombination die erforderliche Meldung anzeigt, übergeben Sie dieser den Wert des Parameters Shift <\/b>mit negativem Vorzeichen (s. Listing 4<\/a><\/span>). 0 <\/b>bedeutet dann False<\/b>, -1 <\/b>heißt True<\/b>.<\/p>\n Listing 4: Löschen einer Aufgabe<\/p>\n Der Prozedur übergeben Sie außerdem noch die ID der zu löschenden Aufgabe. Ist bolLoeschen <\/b>nun False<\/b>, was geschieht, wenn das Element einfach in den leeren Bereich gezogen wird, fragt die Prozedur nach, ob die Aufgabe gelöscht werden soll. Falls bolLoeschen <\/b>den Wert True <\/b>hat, wird direkt gelöscht.<\/p>\n Zurück zur Prozedur objTasks_OLEDragDrop <\/b>und zu dem Fall, dass das Element auf ein anderes Element gezogen wurde. Dann liest die Prozedur zunächst den Key <\/b>des Zielelements in die Variable strKeyDrop <\/b>ein und die ID der entsprechenden Aufgabe in die Variable lngKeyDrop<\/b>. Um einfacher auf das gezogene Element zugreifen zu können, wird dieses mit der Objektvariablen objKeyDrag <\/b>referenziert.<\/p>\n Hier erfolgt nun zunächst die Prüfung, ob das Element auf sich selbst gezogen wurde. Dies würde einen Zirkelbezug und damit einen Fehler auslösen, also wird die Prozedur ohne weitere Aktionen beendet. Anderenfalls wird wiederum geprüft, ob der Benutzer die Umschalttaste gedrückt hält (Shift = 1<\/b>).<\/p>\n Aufgaben zusammenführen<\/b><\/p>\n Wozu aber soll dies gut sein Nun: Das Kopieren von Aufgaben ist wenig sinnvoll, da eine Aufgabe immer nur im Kontext einer übergeordneten Aufgabe stehen und nicht mehrfach vorkommen soll.<\/p>\n Es kann aber vorkommen, dass man feststellt, dass man Aufgaben mehrfach anlegt und pflegt. Um später in Auswertungen vernünftige Daten zu erhalten, müssen diese parallel gepflegten Aufgaben zusammengeführt werden. Dies erledigen Sie, wenn Sie eine Aufgabe bei gedrückter Umschalttaste auf eine andere Aufgabe ziehen:<\/p>\n All dies erledigt die Prozedur AufgabenZusammenfuehren <\/b>mit drei SQL-Statements (siehe Klassenmodul des Formulars frmTagesablauf <\/b>in der Beispieldatenbank).<\/p>\n Aufgaben verschieben<\/b><\/p>\n Bleibt noch das eigentliche Verschieben, das durch bloßes Drag and Drop ohne jegliche Tastenkombination erfolgt. Dies führt zum Aufruf der Prozedur AufgabeVerschieben <\/b>(s. Listing 5<\/a><\/span>). Diese Prozedur erwartet die Primärschlüsselwerte der beiden beteiligten Aufgaben als Parameter.<\/p>\n Listing 5: Verschieben einer Aufgabe<\/p>\n Die erste If…Then<\/b>-Bedingung prüft, ob die Aufgabe auf eine Aufgabe mit dem Primärschlüsselwert 0 <\/b>gezogen wurde. Die gibt es natürlich gar nicht, aber das Root-Element des Aufgabenbaums hat den Key t0<\/b>.<\/p>\n Damit ein Element direkt unterhalb dieses Elements angezeigt wird, darf es keine übergeordnete Aufgabe besitzen. Die entsprechende AufgabeID <\/b>darf also nicht im Feld UnteraufgabeID <\/b>der Tabelle tblAufgabenUnteraufgaben <\/b>vorkommen. Um dies zu erreichen, werden schlicht alle Datensätze aus dieser Tabelle gelöscht, die diese Bedingung erfüllen.<\/p>\n Falls die Aufgabe nicht auf das Root-Element, sondern auf eine echte Aufgabe gezogen wurde, versucht die Prozedur zunächst, einen eventuell vorhandenen Eintrag in der Tabelle tblAufgabenUnteraufgaben <\/b>umzubiegen. Ist keiner vorhanden, war die gezogene Aufgabe wohl zuvor direkt dem Root-Element untergeordnet und es muss ein neuer Eintrag in der Tabelle tblAufgabenUnteraufgaben <\/b>angelegt werden.<\/p>\n Heutige Aufgaben anlegen<\/b><\/p>\n Wenn der Benutzer eine Aufgabe aus dem TreeView in die Liste der heutigen Aufgaben zieht, soll dort ein Eintrag für die entsprechende Aufgabe angelegt werden. Außerdem soll die Eigenschaft HeuteZuErledigen <\/b>auf den Wert True <\/b>eingestellt werden.<\/p>\n Beides erledigt die Ereignisprozedur objDailyTasks_OLEDragDrop<\/b>, die beim Fallenlassen einer Aufgabe im ListView-Steuerelement lvwDailyTasks <\/b>ausgelöst wird (s. Listing 6<\/a><\/span>). Die Prozedur liest den Wert des Parameters Data <\/b>ein und ermittelt über den ersten Buchstaben des enthaltenen Ausdrucks die Herkunft des gezogenen Elements. Lautet dieser Buchstabe t<\/b>, wurde eine Aufgabe aus dem TreeView in die Liste gezogen. In diesem Fall wird die Eigenschaft HeuteZuErledigen <\/b>dieser Aufgabe auf True <\/b>eingestellt. Das anschließende Neufüllen des Listenfeldes führt zum Anzeigen des neuen Eintrags.<\/p>\n Listing 6: Heutige Aufgaben anlegen und entfernen<\/p>\n Es gibt jedoch noch eine zweite Variante: Der Benutzer kann auch einen vorhandenen Eintrag in den leeren Bereich des ListView-Steuerelements ziehen, um diesen aus der Liste zu entfernen. Das bedeutet, dass der Parameter Data <\/b>einen mit dem Buchstaben d <\/b>beginnenden Eintrag liefert. Die Prozedur prüft dann noch, ob der Eintrag tatsächlich auf den leeren Bereich gezogen wurde (objDailyTasks.Hittext(x,y) Is Nothing<\/b>), und stellt die Eigenschaft HeuteZuErledigen <\/b>der Aufgabe auf den Wert False <\/b>ein. Nach der Aktualisierung verschwindet dieser Eintrag aus der Liste.<\/p>\n Tätigkeiten anlegen<\/b><\/p>\n Das Listenfeld lvwTimeplan <\/b>bietet einige Drag-and-Drop-Möglickeiten, die in der Ereignisprozedur objTimeplan_OLEDragDrop <\/b>abgearbeitet werden (s. Listing 7<\/a><\/span>). Auch diese Prozedur speichert den Wert des Parameters Data<\/b>, der Informationen über das gezogene Element liefert, in der Variablen strData<\/b>. Aus dieser wird der erste Buchstabe als Kennzeichen für das Herkunftssteuerelement in der Variablen strDatatype <\/b>gespeichert. Die ID des Elements landet in der Variablen lngKeyDrag<\/b>.<\/p>\n Listing 7: Tätigkeiten anlegen und verschieben<\/p>\n Danach folgt eine Prüfung, ob ein bestehender Listeneintrag als Ziel der Drag-and-Drop-Operation verwendet wurde. Falls nicht, wird die Prozedur beendet. Falls doch, sammelt die Prozedur die Informatoinen über das Zielelement in den Variablen strKeyDrop <\/b>und lngKeyDrop<\/b>. lngKeyDrop <\/b>entspricht dabei der Position des Zieleintrags.<\/p>\n Zeigt das ListView-Steuerelement 8:00 <\/b>als ersten Eintrag an und zieht der Benutzer eine Aufgabe auf diesen Eintrag, erhält lngKeyDrop <\/b>beispielsweise den Wert 1<\/b>.<\/p>\n Danach folgt eine Select Case<\/b>-Bedingung, die je nach der Herkunft des gezogenen Elements verschiedene Aktionen durchführt.<\/p>\n Kommt das Element vom Aufgaben-TreeView, wird das Element referenziert und sein Text in die zweite Spalte des Zielelements geschrieben. Gleiches gilt, wenn das Element von der Liste der heutigen Aufgaben auf die Tätigkeitsliste gezogen wurde. Etwas komplizierter wird es, wenn der Benutzer einen Eintrag der Tätigkeitsliste auf einen anderen Eintrag der Tätigkeitsliste gezogen hat. In diesem Fall prüft die Prozedur zunächst, ob der Eintrag auf sich selbst gezogen wurde, und beendet gegebenenfalls die Prozedur.<\/p>\n Anderenfalls liest sie mit einer DLookup<\/b>-Anweisung die AufgabeID <\/b>ein, auf welcher die gezogene Tätigkeit basiert. Ist diese nicht Null, stellt die Prozedur den Text des Zielelements auf den Text des Quellelements ein. Nun kommt es noch darauf an, ob das Element bei gedrückter Strg<\/b>-Taste gezogen wurde. Falls ja, soll das Element kopiert werden, falls nein, wird es verschoben. Ersteren Fall hätten wir bereits erledigt: Das bestehende Element ist noch vorhanden, das neue Element wurde angelegt. Wenn das Element verschoben werden soll, müssen wir das gezogene Element also noch löschen. Dies erledigt die Prozedur mit einer entsprechenden DELETE-SQL-Anweisung. Außerdem wird der Text des entsprechenden Elements noch geleert.<\/p>\n Sicher ist Ihnen aufgefallen, dass die beschriebenen Anweisungen dieser Prozedur bislang zwar eine Menge Elemente verschoben und kopiert haben, jedoch wurde nur das innerhalb der Tätigkeitenliste verschobene Element auch in der zugrunde liegenden Tabelle gelöscht – und immerhin haben wir in der Select Case<\/b>-Anweisung bereits alle möglichen Fälle abgearbeitet.<\/p>\n\n
![\"pic001.png\"](\"..\/fileadmin\/_temp_\/2012_03\/DragAndDropMitTreeViewUndListView-web-images\/pic001.png\")
<\/p>\n\n
![\"pic002.png\"](\"..\/fileadmin\/_temp_\/2012_03\/DragAndDropMitTreeViewUndListView-web-images\/pic002.png\")
<\/p>\nobjTasks.OLEDragMode = ccOLEDragAutomatic\r\nobjTasks.OLEDropMode = ccOLEDropManual<\/pre>\n
Private Sub objTasks_OLEStartDrag(Data As MSComctlLib.DataObject, AllowedEffects As Long)\r\n Dim objNode As MSComctlLib.Node\r\n Set objNode = objTasks.SelectedItem\r\n If objNode Is Nothing Then Exit Sub\r\n Data.Clear\r\n Data.SetData objNode.Key, ccCFText\r\nEnd Sub\r\nPrivate Sub objTimeplan_OLEStartDrag(Data As MSComctlLib.DataObject, AllowedEffects As Long)\r\n Dim objListitem As MSComctlLib.ListItem\r\n Set objListitem = objDailyTasks.SelectedItem\r\n If objListitem Is Nothing Then Exit Sub\r\n Data.Clear\r\n Data.SetData objListitem.Key, ccCFText\r\nEnd Sub\r\nPrivate Sub objDailyTasks_OLEStartDrag(Data As MSComctlLib.DataObject, AllowedEffects As Long)\r\n ... wie objTimeplan_OLEStartDrag\r\nEnd Sub<\/pre>\n
Private Sub objTasks_OLEDragOver(Data As MSComctlLib.DataObject, Effect As Long, _\r\n Button As Integer, Shift As Integer, x As Single, y As Single, State As Integer)\r\n Dim strData As String\r\n Dim strDatatype As String\r\n If Data.GetFormat(ccCFText) = False Then Exit Sub\r\n strData = Data.GetData(ccCFText)\r\n strDatatype = Left(strData, 1)\r\n Select Case strDatatype\r\n Case "t"\r\n Set objTasks.DropHighlight = objTasks.HitTest(x, y)\r\n End Select\r\nEnd Sub<\/pre>\n
Select Case strDatatype\r\n Case "t", "d", "p"\r\n Set objTimeplan.DropHighlight = objTimeplan.HitTest(x, y)\r\nEnd Select<\/pre>\n
\n
Private Sub objTasks_OLEDragDrop(Data As MSComctlLib.DataObject, Effect As Long, _\r\n Button As Integer, Shift As Integer, x As Single, y As Single)\r\n ''... Deklaration\r\n strData = Data.GetData(ccCFText)\r\n strDatatype = Left(strData, 1)\r\n lngKeyDrag = Mid(strData, 2)\r\n Set objNodeDrop = objTasks.HitTest(x, y)\r\n Select Case strDatatype\r\n Case "t"\r\n If objNodeDrop Is Nothing Then\r\n AufgabeLoeschen lngKeyDrag, -Shift\r\n Else\r\n strKeyDrop = objNodeDrop.Key\r\n lngKeydrop = Mid(strKeyDrop, 2)\r\n Set objNodeDrag = objTasks.Nodes(strData)\r\n If strKeyDrop = strKeyDrag Then\r\n Exit Sub\r\n End If\r\n Select Case Shift\r\n Case 0 ''verschieben\r\n AufgabeVerschieben lngKeydrop, lngKeyDrag\r\n Case 1\r\n AufgabenZusammenfuehren Mid(objNodeDrag.Key, 2), Mid(objNodeDrop.Key, 2)\r\n End Select\r\n FillTree\r\n End If\r\n End Select\r\nEnd Sub<\/pre>\n
Public Function AufgabeLoeschen(lngAufgabeID As Long, bolLoeschen As Boolean)\r\n Dim db As DAO.Database\r\n Set db = CurrentDb\r\n If bolLoeschen = False Then\r\n bolLoeschen = MsgBox("Aufgabe wirklich löschen", vbOKCancel + vbExclamation, _\r\n "Aufgabe löschen") = vbOK\r\n End If\r\n If bolLoeschen = True Then\r\n db.Execute "DELETE tblAufgaben.* FROM tblAufgaben INNER JOIN tblAufgabenUnteraufgaben " _\r\n & "ON tblAufgaben.AufgabeID = tblAufgabenUnteraufgaben.UnteraufgabeID "_\r\n & "WHERE tblAufgabenUnteraufgaben.AufgabeID = " & lngAufgabeID, dbFailOnError\r\n db.Execute "DELETE FROM tblAufgaben WHERE AufgabeID = " & lngAufgabeID, dbFailOnError\r\n objTasks.Nodes.Remove "t" & lngAufgabeID\r\n End If\r\nEnd Function<\/pre>\n\n
Private Sub AufgabeVerschieben(lngKeydrop As Long, lngKeyDrag As Long)\r\n Dim db As DAO.Database\r\n Set db = CurrentDb\r\n If lngKeydrop = 0 Then\r\n db.Execute "DELETE FROM tblAufgabenUnteraufgaben WHERE UnteraufgabeID = " _\r\n & lngKeyDrag, dbFailOnError\r\n Else\r\n db.Execute "UPDATE tblAufgabenUnteraufgaben SET AufgabeID = " & lngKeydrop _\r\n & " WHERE UnteraufgabeID = " & lngKeyDrag, dbFailOnError\r\n If db.RecordsAffected = 0 Then\r\n db.Execute "INSERT INTO tblAufgabenUnteraufgaben(AufgabeID, UnteraufgabeID) VALUES(" _\r\n & lngKeydrop & ", " & lngKeyDrag & ")", dbFailOnError\r\n End If\r\n End If\r\n Set db = Nothing\r\nEnd Sub<\/pre>\nPrivate Sub objDailyTasks_OLEDragDrop(Data As MSComctlLib.DataObject, Effect As Long, _\r\n Button As Integer, Shift As Integer, x As Single, y As Single)\r\n Dim strData As String\r\n Dim strDatatype As String\r\n Dim lngKeyDrag As Long\r\n Dim db As DAO.Database\r\n Set db = CurrentDb\r\n strData = Data.GetData(ccCFText)\r\n strDatatype = Left(strData, 1)\r\n lngKeyDrag = Mid(strData, 2)\r\n Select Case strDatatype\r\n Case "t"\r\n db.Execute "UPDATE tblAufgaben SET HeuteErledigen = True WHERE AufgabeID = " _\r\n & lngKeyDrag, dbFailOnError\r\n Case "d"\r\n If objDailyTasks.HitTest(x, y) Is Nothing Then\r\n db.Execute "UPDATE tblAufgaben SET HeuteErledigen = False WHERE AufgabeID = " _\r\n & lngKeyDrag, dbFailOnError\r\n End If\r\n End Select\r\n FillDailyTasks\r\n Set db = Nothing\r\nEnd Sub<\/pre>\n
Private Sub objTimeplan_OLEDragDrop(Data As MSComctlLib.DataObject, Effect As Long, _\r\n Button As Integer, Shift As Integer, x As Single, y As Single)\r\n ''... Variablendeklaration\r\n Set db = CurrentDb\r\n strData = Data.GetData(ccCFText)\r\n strDatatype = Left(strData, 1)\r\n lngKeyDrag = Mid(strData, 2)\r\n Set objDrop = objTimeplan.HitTest(x, y)\r\n If objDrop Is Nothing Then\r\n Exit Sub\r\n End If\r\n strKeyDrop = objDrop.Key\r\n lngKeydrop = Mid(strKeyDrop, 2)\r\n Select Case strDatatype\r\n Case "t" ''from tvwTasks\r\n Set objDrag = objTasks.Nodes(strData)\r\n objDrop.ListSubItems(1).Text = objDrag.Text\r\n Case "d" ''from lvwDailyTasks\r\n Set objDrag = objDailyTasks.ListItems(strData)\r\n objDrop.ListSubItems(1).Text = objDrag.Text\r\n Case "p" ''from lvwTimeplan\r\n Set objDrag = objTimeplan.ListItems(strData)\r\n If strKeyDrop = strKeyDrag Then\r\n Exit Sub\r\n End If\r\n lngKeyDrag = Nz(DLookup("AufgabeID", "tblTaetigkeiten", "TaetigkeitID = " & objDrag.Tag))\r\n If Not IsNull(lngKeyDrag) Then\r\n objDrop.ListSubItems(1).Text = objDrag.ListSubItems(1).Text\r\n If Shift = 0 Then ''verschieben\r\n db.Execute "DELETE FROM tblTaetigkeiten WHERE Taetigkeitdatum = " _\r\n & ISODatum(Me!txtDatum) & " AND Taetigkeitzeit = " _\r\n & ISODatum(objDrag.Text), dbFailOnError\r\n objDrag.ListSubItems(1).Text = ""\r\n End If\r\n End If\r\n End Select\r\n objDrop.Tag = AddTaskToTimeplan(lngKeyDrag, Me!txtDatum, objDrop.Text)\r\n If Not objDrag Is Nothing Then objDrag.Selected = False\r\n Set objTimeplan.DropHighlight = Nothing\r\n Set db = Nothing\r\nEnd Sub<\/pre>\n