DragDrop-Sample

    • VB.NET

    Es gibt 13 Antworten in diesem Thema. Der letzte Beitrag () ist von ErfinderDesRades.

      DragDrop-Sample

      primitiv-Sample, wie anwendungsübergreifendes DragnDrop umsetzbar ist:

      VB.NET-Quellcode

      1. Imports System.Collections.Specialized
      3. Public Class frmDragDropSample
      5. Private Sub Control_DragDrop(ByVal sender As Object, ByVal e As DragEventArgs) _
      6. Handles TextBox1.DragDrop, ListBox1.DragDrop
      7. Dim data = DirectCast(e.Data, DataObject)
      8. Select Case True
      9. Case sender Is TextBox1
      10. 'zum Testen kann Text aussm VS-Editor auf die Textbox gezogen werden
      11. Dim txt As String = data.GetText
      12. TextBox1.AppendText(txt & Environment.NewLine)
      14. Case sender Is ListBox1
      15. 'zum Testen können Dateien/Ordner aussm DateiBrowser auf die ListBox gezogen werden
      16. Dim files As StringCollection = data.GetFileDropList
      17. For Each file As String In files
      18. ListBox1.Items.Add(file)
      19. Next
      20. End Select
      21. End Sub
      23. Private Sub Control_DragEnter(ByVal sender As Object, ByVal e As DragEventArgs) _
      24. Handles ListBox1.DragEnter, TextBox1.DragEnter
      25. 'erlaubte DropEffects festlegen
      26. Dim data = DirectCast(e.Data, DataObject)
      27. Select Case True
      28. Case sender Is TextBox1
      29. If data.ContainsText Then e.Effect = DragDropEffects.All
      31. Case sender Is ListBox1
      32. If data.ContainsFileDropList Then e.Effect = DragDropEffects.All
      33. End Select
      34. End Sub
      36. End Class

      Vorraussetzung, dass ühaupt auf ein Control gedropt werden kann, ist, dass seine
      Control.AllowDrop - Property auf True eingestellt ist (ist hier im FormDesigner erledigt, geht aber auch per Code)

      Wichtig ist v.a. das Verständnis des DataObjects, das in den EventArgs angeliefert wird.
      Ein DataObject enthält die Daten, zuzüglich Informationen über den Datentyp.
      Es kann "dieselben" Daten in verschiedenen Formaten enthalten (zB sowohl als "Text", als auch als "Richtext") - hier wird aber jeweils nur ein Format abgefragt.
      Ist (im Drag_Enter) das gewünschte Datenformat nicht enthalten, so wird kein DragDropEffect gesetzt, und dann kann auch nicht gedropt werden (was dem User mittels des entsprechenden Cursor-Icon angezeigt wird)

      VB.NET-Quellcode

      1. Dim data = DirectCast(e.Data, DataObject)
      e.Data wird etwas unspezifisch als IDataObject angeliefert - der Cast auf System.Windows.Forms.DataObject erleichtert die Handhabung.

      data.GetFileDropList wird als System.Collections.Specialized.StringCollection angeliefert - das ist eiglich ein veralteter AuflistungsTyp für Strings - heutzutage nähme man natürlich List(Of String). Aber DragnDrop ist halt älter als das Framework2, und wg. Abwärtskompatibilität habenses wohl so belassen.

      weitere Möglichkeiten von DragnDrop
      Im DragEnter kann mit

      VB.NET-Quellcode

      1. Dim modifiers As Keys = Control.ModifierKeys
      der Status der Modifier-Tasten (Shift, Strg, Alt, Alt+Strg) abgefragt werden, und dementsprechend der gemeinte DropEffect festgelegt werden - was dem User per Cursor-Icon signalisiert wird.
      Dieser Effect wird dann auch ins DragDrop-Event transportiert, sodass dort spezifisch reagiert werden kann, etwa "Kopieren" im Unterschied zu "Verschieben", und derlei Dinge.

      Auch kann statt des _DragEnter-Events das _DragOver-Event verarbeitet werden, welches in schneller Folge während des gesamten DragOvers gefeuert wird.
      Dadurch erhält der User Gelegenheit, mittels der Modifier-Tasten, die gemeinte Aktion noch während des Draggens zu ändern.


      Sample-Code-Zips:
      DragDropSample ist das Sample hier zu diesem Post, also einfaches anwendungsübergreifendes Dragging.

      DragjobTester ist ein Sample für Draggen innerhalb der Anwendung. Das ist im Grunde ein wesentlich verschiedenes Thema, auf das ich erst in post#9 eingehe.
      ich häng nun noch DragjobTester an, ein klein Projekt für Draggen innerhalb der Anwendung.
      Besonderer Trick dabei ist, dass von einem DatagridView mit Multiselection gedraggt wird. Die Crux speziell dabei ist, dass das DGV seine Selection bereits beim MouseDown löscht.
      Daher habe ich eine Speicherklasse für diese Selection mir ausgedacht, mit der man sie eben wieder herstellen kann.
      Dateien

      Dieser Beitrag wurde bereits 9 mal editiert, zuletzt von „ErfinderDesRades“ ()

      Hi
      halte ich immernoch für unsauber. Nicht jedes IDataObject ist gleichzeitig ein DataObject. Die Abfrage mit Select Case ist mMn ebenfalls etwas unschön anzusehen. Da wäre es fast besser, die Methoden in Funktionen auszulagern und jeweils einen Wert zurückzugeben, ob der Drag-Drop-Vorgang erfolgreich wäre bzw. erfolgreich war und bei letzterem noch in einem mit ByRef übergebenen Parameter den letztendlich gespeicherten Wert zurückzugeben. Das Auslagern kommt halt aber nur in Frage, wenn man mehrere Controls hat.
      Das wäre z.B. eine Lösung, wie ich sie in etwa programmiert hätte. Der von e.Data.GetData kann meines Wissens nicht Nothing sein (korrigiert mich bzw. den Code, wenn ich falsch liege). Ich habe das deshalb im Code nicht extra behandelt. Außerdem wäre es schön, wenn es ein Ereignis gäbe, das bei Änderung der Modifizierer geworfen wird, das habe ich aber bisher noch nicht entdeckt. Damit könnte man das DragOver umgehen.

      VB.NET-Quellcode

      1. Private Sub ControlInstance_DragDrop(ByVal sender As Object, ByVal e As System.Windows.Forms.DragEventArgs) Handles ControlInstance.DragDrop
      2. 'Effekt bestimmen, der verwendet wird (hier ist nur Link erlaubt)
      3. Dim effect As DragDropEffects = e.AllowedEffect And (DragDropEffects.Link)
      4. If effect <> DragDropEffects.None Then
      5. 'Erlaubte Daten ueberpruefen
      6. If e.Data.GetDataPresent(DataFormats.FileDrop) Then 'Dateiliste wird gedroppt
      7. 'gedroppte Daten ermitteln
      8. Dim data As Object = e.Data.GetData(DataFormats.FileDrop)
      9. 'gedrueckte Mousebuttons
      10. Dim mouseButtons As Keys = CType(e.KeyState And (Keys.LButton Or Keys.RButton Or Keys.XButton1 Or Keys.XButton2 Or Keys.MButton), Keys)
      11. 'gedrueckte Modifizierer
      12. Dim modifiers As Keys = CType(e.KeyState And (Keys.Control Or Keys.Alt Or Keys.Shift), Keys)
      13. 'Typen behandeln
      14. If TypeOf data Is IEnumerable(Of String) Then
      15. 'Iteration durch die in der Auflistung gespeicherten Strings moeglich
      17. 'Spezifische Verarbeitung (hier Ausgabe in der Text-Eigenschaft des senders).
      18. Dim sb As New System.Text.StringBuilder(2048)
      19. For Each file As String In DirectCast(data, IEnumerable(Of String))
      20. sb.AppendLine(file)
      21. Next
      22. DirectCast(sender, Control).Text = sb.ToString()
      23. 'Hier wird dann der Effekt ermittelt, der verwendet werden soll
      24. 'z.B. hier: wird mit der linken Maustaste gedroppt, wird der guenstigste Fall genommen (hier Link)
      25. If mouseButtons = Keys.LButton Then
      26. 'kann gar nichts anderes, als Link sein, wird aber fuer andere Verwendungs-
      27. 'zwecke trotzdem wie nachfolgend behandelt
      28. If (effect And DragDropEffects.Link) = DragDropEffects.Link Then
      29. e.Effect = DragDropEffects.Link
      30. Else
      31. e.Effect = DragDropEffects.None
      32. End If
      33. Else
      34. 'hier koennte man z.B. ein Kontextmenu anzeigen lassen
      35. e.Effect = DragDropEffects.None
      36. End If
      37. ElseIf TypeOf data Is IEnumerable Then
      38. 'gibt an, ob data Strings enthaelt
      39. Dim valid As Boolean = False
      40. 'Iteration durch die in der Auflistung gespeicherten Strings moeglich
      42. 'Spezifische Verarbeitung (hier Ausgabe in der Text-Eigenschaft des senders).
      43. Dim sb As New System.Text.StringBuilder(2048)
      44. For Each entry As Object In DirectCast(data, IEnumerable)
      45. If TypeOf entry Is String Then
      46. sb.AppendLine(DirectCast(entry, String))
      47. valid = True
      48. End If
      49. Next
      50. 'ist die IEnumerable gueltig, die Text-Eigenschaft setzen, ansonsten ist der DragDrop-Vorgang
      51. 'ungueltig
      52. If valid Then
      53. DirectCast(sender, Control).Text = sb.ToString()
      54. 'Hier wird dann der Effekt ermittelt, der verwendet werden soll
      55. 'z.B. hier: wird mit der linken Maustaste gedroppt, wird der guenstigste Fall genommen (hier Link)
      56. If mouseButtons = Keys.LButton Then
      57. 'kann gar nichts anderes, als Link sein, wird aber fuer andere Verwendungs-
      58. 'zwecke trotzdem wie nachfolgend behandelt
      59. If (effect And DragDropEffects.Link) = DragDropEffects.Link Then
      60. e.Effect = DragDropEffects.Link
      61. Else
      62. e.Effect = DragDropEffects.None
      63. End If
      64. Else
      65. 'hier koennte man z.B. ein Kontextmenu anzeigen lassen
      66. e.Effect = DragDropEffects.None
      67. End If
      68. Else
      69. e.Effect = DragDropEffects.None
      70. End If
      71. Else
      72. e.Effect = DragDropEffects.None
      73. 'Typen nicht unterstuetzt, der Else-Block tritt normalerweise nicht ein (Behandlung bereits im
      74. 'DragOver/DragEnter-Event) Ansonsten hier andere Faelle behandeln
      75. End If
      76. Else
      77. 'Alles Andere wird nicht unterstuetzt
      78. e.Effect = DragDropEffects.None
      79. End If
      80. Else
      81. 'Keiner der erlaubten Effekte wird vom DragDrop erfasst
      82. e.Effect = DragDropEffects.None
      83. End If
      84. End Sub
      86. Private Sub ControlInstance_DragEnter(ByVal sender As Object, ByVal e As System.Windows.Forms.DragEventArgs) Handles ControlInstance.DragEnter
      87. 'Effekt bestimmen, der verwendet wird (hier ist nur Link erlaubt)
      88. Dim effect As DragDropEffects = e.AllowedEffect And (DragDropEffects.Link)
      89. If effect <> DragDropEffects.None Then
      90. 'Auf zugelassene Modifizierer ueberpruefen (hier ist nur LButton erlaubt)
      91. 'Die Mausbuttons LButton, RButton, MButton, XButton1, XButton2 und die Modifizierer Shift, Alt, Control
      92. 'lassen sich mit Or kombinieren
      93. If e.KeyState = Keys.LButton Then 'e.KeyState auf alle erlaubten Kombinationen ueberpruefen
      94. 'Erlaubte Daten ueberpruefen
      95. If e.Data.GetDataPresent(DataFormats.FileDrop) Then 'Dateiliste wird gedroppt
      96. Dim data As Object = e.Data.GetData(DataFormats.FileDrop)
      97. 'zugelassene Typen beschraenken
      98. If TypeOf data Is IEnumerable(Of String) Then
      99. e.Effect = effect
      100. ElseIf TypeOf data Is IEnumerable Then
      101. 'wenn die Auflistung mindestens einen String enthaelt, ist sie gueltig
      102. For Each entry As Object In DirectCast(data, IEnumerable)
      103. If TypeOf entry Is String Then
      104. e.Effect = effect
      105. Exit Sub
      106. End If
      107. Next
      108. Else
      109. e.Effect = DragDropEffects.None
      110. End If
      111. 'hier andere Faelle behandeln
      112. Else
      113. 'Alles Andere wird nicht unterstuetzt
      114. e.Effect = DragDropEffects.None
      115. End If
      116. End If
      117. Else
      118. e.Effect = DragDropEffects.None
      119. End If
      120. End Sub
      122. 'DragEnter und DragOver behandeln (DragOver kann bei Gleichgueltigkeit der Modifizierer weggelassen werden)
      123. Private Sub ControlInstance_DragOver(ByVal sender As Object, ByVal e As System.Windows.Forms.DragEventArgs) Handles ControlInstance.DragOver
      124. 'Effekt bestimmen, der verwendet wird (hier ist nur Link erlaubt)
      125. Dim effect As DragDropEffects = e.AllowedEffect And (DragDropEffects.Link)
      126. If effect <> DragDropEffects.None Then
      127. 'Auf zugelassene Modifizierer ueberpruefen (hier ist nur LButton erlaubt)
      128. 'Die Mausbuttons LButton, RButton, MButton, XButton1, XButton2 und die Modifizierer Shift, Alt, Control
      129. 'lassen sich mit Or kombinieren
      130. If e.KeyState = Keys.LButton Then 'e.KeyState auf alle erlaubten Kombinationen ueberpruefen
      131. 'Erlaubte Daten ueberpruefen
      132. If e.Data.GetDataPresent(DataFormats.FileDrop) Then 'Dateiliste wird gedroppt
      133. e.Effect = effect
      134. Else
      135. 'Alles Andere wird nicht unterstuetzt
      136. e.Effect = DragDropEffects.None
      137. End If
      138. End If
      139. Else
      140. e.Effect = DragDropEffects.None
      141. End If
      142. End Sub


      Gruß
      ~blaze~

      Dieser Beitrag wurde bereits 2 mal editiert, zuletzt von „~blaze~“ ()

      Du kannst aber auch eigene Klasse von IDataObject ableiten und die OnDragDrop-Prozeduren etc. mit entsprechenden EventArgs füttern. Da man Tutorials und Tipps möglichst allgemeingültig halten sollte, würde ich daher dazu tendieren, das so handzuhaben - zumindest würde ich das immer so machen. Bei meinen Verbesserungsvorschlägen handelt es sich nur um Vorschläge. Ob sie angenommen werden oder nicht ist dem Leser überlassen.

      Gruß
      ~blaze~

      Du kannst aber auch eigene Klasse von IDataObject ableiten
      Du meinst: Implementieren.
      Das ist immerhin eine theoretische Möglichkeit, und wollte ich auch gleich ausprobieren:

      VB.NET-Quellcode

      1. Public Class MyDataObject : Implements IDataObject
      3. Public Function GetData(ByVal format As String) As Object Implements System.Windows.Forms.IDataObject.GetData
      4. End Function
      5. Public Function GetData(ByVal format As String, ByVal autoConvert As Boolean) As Object Implements System.Windows.Forms.IDataObject.GetData
      6. End Function
      7. Public Function GetData(ByVal format As System.Type) As Object Implements System.Windows.Forms.IDataObject.GetData
      8. End Function
      9. Public Function GetDataPresent(ByVal format As String) As Boolean Implements System.Windows.Forms.IDataObject.GetDataPresent
      10. End Function
      11. Public Function GetDataPresent(ByVal format As String, ByVal autoConvert As Boolean) As Boolean Implements System.Windows.Forms.IDataObject.GetDataPresent
      12. End Function
      13. Public Function GetDataPresent(ByVal format As System.Type) As Boolean Implements System.Windows.Forms.IDataObject.GetDataPresent
      14. End Function
      15. Public Function GetFormats() As String() Implements System.Windows.Forms.IDataObject.GetFormats
      16. End Function
      17. Public Function GetFormats(ByVal autoConvert As Boolean) As String() Implements System.Windows.Forms.IDataObject.GetFormats
      18. End Function
      19. Public Sub SetData(ByVal data As Object) Implements System.Windows.Forms.IDataObject.SetData
      20. End Sub
      21. Public Sub SetData(ByVal format As String, ByVal autoConvert As Boolean, ByVal data As Object) Implements System.Windows.Forms.IDataObject.SetData
      22. End Sub
      23. Public Sub SetData(ByVal format As String, ByVal data As Object) Implements System.Windows.Forms.IDataObject.SetData
      24. End Sub
      25. Public Sub SetData(ByVal format As System.Type, ByVal data As Object) Implements System.Windows.Forms.IDataObject.SetData
      26. End Sub
      28. End Class
      Allerdings sehe ich mich außerstande, all diese von IDataObject geforderten Methoden-Stubs sinnvoll auszufüllen.
      In .Net würde auch niemand so programmieren, sondern stattdessen vom Forms.DataObject erben (und damit das ganze Gedöhns), statt es selbst zu implementieren.

      Ich empfehle dennoch den Cast aufs Window.Forms.DataObject, wegen seiner einfacheren Bedienung der Standard-Fälle.
      Will man hingegen auch mit ausgefallenen Anwendungen kommunizieren, die tatsächlich abweichende IDataObjekte verschicken, so muß man sich halt auf die Bedienung dieser Schnittstelle verlegen.
      Aber ich modifiziere mal, indem ich einen TryCast verwende, der solche "Exoten" einfach als Drag-Quelle ausschließt:

      VB.NET-Quellcode

      1. 'DropEffect festlegen - da hier eh nur eine Aktion pro Control stattfindet, ist der
      2. 'gewählte DropEffect schnurz - Hauptsache, er ist nicht DropEffects.None
      3. Private Sub Control_DragOver(ByVal sender As Object, ByVal e As DragEventArgs) _
      4. Handles ListBox1.DragOver, TextBox1.DragOver
      5. Dim data = TryCast(e.Data, DataObject)
      6. If data Is Nothing Then
      7. Return ' DragQuelle ablehnen, weils DataObject nicht verarbeitet werden kann
      8. End If
      9. Select Case True
      10. Case sender Is TextBox1
      11. If data.ContainsText Then e.Effect = DragDropEffects.All
      13. Case sender Is ListBox1
      14. If data.ContainsFileDropList Then e.Effect = DragDropEffects.All
      15. End Select
      16. End Sub

      Die Abfrage mit Select Case ist mMn ebenfalls etwas unschön anzusehen.
      Also ich finde die besonders schön :). Dadurch wird gleiches in einer Methode zusammengefasst, und unterschiedliches unterschieden (Select Case halt).
      Der unterschiedliche Code beschränkt sich ja jeweils auf eine (maximal 3) Zeilen - dafür braucht man IMO nicht eine Extra-Methode in der Klasse rumfahren zu haben.
      Wie immer bei vielen Fallunterscheidungen wird Code unübersichtlich (deiner ist kein schlechtes Beispiel dafür ;)) - also dieses Zusammenfassen von Gleichem ist tatsächlich recht begrenzt, und sollte ab einer gewissen Komplexität aufgelöst werden in verschiedene Methoden.

      Aber zu deim Code habich auch Anmerkungen (plusse und minusse):
      • zunächstmal liegt er mehr auf der sicheren Seite. Wegen der Sache mit den exotischen DataObjekten, und auch, dass du überprüfst, wenn "FileDropList" angegeben ist, dass dann auch ein IEnumerable(Of String) drinne ist - je länger ich darüber hirne, desto besser gefällt mir das - ist ja auch nicht soo viel aufwändiger ;)
      • Du testest e.KeyState, wo ich Control.ModifierKeys bevorzuge. Letztere bevorzuge ich, weil sie als Keys typisiert sind, und Intellisense mir dann gleich die richtigen Optionen anzeigt. e.KeyState hingegen hat den Vorteil, dass auch die MouseButtons drin enthalten sind.
        (Ich finde allerdings, man sollte der Konvention folgen, dass Draggen mit die linke Maustaste gehört, und die rechte für KontextMenüs ist. DropEffects sollten per ModifierTasten bestimmt werden, nicht über die Maus)
      • Das explizite Setzen von DropEffect.None ist nicht nötig - .None ist default
      • Das _DragEnter braucht ühaupt nicht berücksichtigt werden, wenn man das _DragOver verarbeitet.
      • Im DragDrop braucht nicht auf DropEffect.None geprüft werden, denn wenn im _DragOver nichts gesetzt ist (->DropEffect.None), kann es zu keinem Drop-Event kommen.
      • Auch braucht im _DragDrop nicht erneut der Effect geprüft werden (in diesem Fall), und ganz allgemein sind dort keine Modifiers zu testen, sondern es ist einfach die Aktion umzusetzen, die der User durch den zuvor gesetzten DropEffekt spezifiziert hat.
      • Ich stauche mal dein Code zusammen, ohne iwas vonne Funktionalität zu ändern (die höhere Sicherheit erkenne ich ja an)

      VB.NET-Quellcode

      1. Private Sub ControlInstance_DragDrop(ByVal sender As Object, ByVal e As DragEventArgs) Handles ControlInstance.DragDrop
      2. 'Spezifische Verarbeitung (hier Ausgabe in der Text-Eigenschaft des senders.
      3. 'keinerlei Absicherung, denn Absicherung ist Sache des DragOver-Events
      4. Dim files = e.Data.GetData(DataFormats.FileDrop)
      5. Dim sb As New System.Text.StringBuilder(2048)
      6. For Each file As String In DirectCast(files, IEnumerable(Of String))
      7. sb.AppendLine(file)
      8. Next
      9. DirectCast(sender, Control).Text = sb.ToString()
      10. End Sub
      12. Private Sub ControlInstance_DragOver(ByVal sender As Object, ByVal e As DragEventArgs) Handles ControlInstance.DragOver
      13. 'Effekt bestimmen, der verwendet wird (hier ist nur Link erlaubt)
      14. If Not e.AllowedEffect.HasFlag(DragDropEffects.Link) Then Return
      15. 'Auf zugelassene Modifizierer ueberpruefen (hier ist nur LButton erlaubt)
      16. 'Die Mausbuttons LButton, RButton, MButton, XButton1, XButton2 und die Modifizierer Shift, Alt, Control
      17. 'lassen sich mit Or kombinieren
      18. If e.KeyState <> Keys.LButton Then Return 'e.KeyState auf alle erlaubten Kombinationen ueberpruefen
      19. 'gewünschtes DatenFormat enthalten?
      20. If Not e.Data.GetDataPresent(DataFormats.FileDrop) Then Return
      21. 'liegen die Daten in verarbeitbarer Form vor?
      22. Dim files = e.Data.GetData(DataFormats.FileDrop)
      23. If TypeOf files Is IEnumerable(Of String) Then e.Effect = DragDropEffects.Link
      24. End Sub

      Dieser Beitrag wurde bereits 2 mal editiert, zuletzt von „ErfinderDesRades“ ()

      Ich denke mal, in den meisten Fällen dürfte dein jetziger Code richtig funktionieren. Im Prinzip ist eigentlich noch eine kleine Unschönheit mit drin. e.Effect müsste mit Or verknüpft werden, da es ja mehrere EventHandler geben kann. Das hatte ich oben vergessen. Ansonsten ist es eine reine Vorsichtsmaßnahme für Programmierer, die OnDragDrop mit einem EventArgs verwenden, das bereits einen Effect eingetragen hat ;). Naja, man kanns einfach weglassen. Das Kontextmenü muss man eh manuell einblenden, oder? Im Kontextmenü kann man dann ja alle zugelassenen Effekte auflisten und den Benutzer auswählen lassen. Dazu wäre die Verwendung eines neuen Threads vmtl. am besten. Den Thread, auf dem der Drag-Drop-Vorgang stattgefunden hat, kann man ja per Anwendungskontext zur Nachrichtenverarbeitung übergehen lassen, bis das ContextMenuStrip geschlossen wird.
      Ich machs meistens doppelt genau, wenns um so Sachen geht, wie MouseMove, DragOver und MouseEnter und DragEnter. Da hast du aber eigentlich schon recht. Das werd' ich zukünftig auch so handhaben. Im DragOver- & DragEnter-Handler hatte ich ursprünglich e.Effect auf e.AllowedEffect And (DragDropEffects.Copy Or DragDropEffects.Move) gesetzt, was aber aufgrund der letztendlichen Implementierung von DragDrop keinen Sinn mehr gemacht hat. Bei DragDrop wurde dann noch entschieden, welcher der beiden Effekte letztendlich angewendet wird. Daher macht's schon Sinn, dass ich den Effekt noch mal extra behandle und sicher ist sicher. Wenn die Maus nicht mehr bewegt wird, sich die Modifizierer aber noch mal ändern, ändert sich der Effekt halt nicht.
      Ansonsten kanns unter Umständen zu Fehlern kommen, wenn eine DragOver-Message ankommt, die Form aber gerade dabei ist, eine Message zu verarbeiten, die etwas mehr Zeit benötigt. Dadurch ändert sich aber auch der Wert der ModifierKeys-Eigenschaft und die Benutzung der e.KeyState-Eigenschaft wäre fast besser.

      Wenn man von DataObject erbt, sind halt eventuell ungenutzte Felder drin.

      Gruß
      ~blaze~

      Ich habe den Code noch mal überarbeitet. ErfinderDesRades hat mich darauf aufmerksam gemacht, dass die StringCollection das IEnumerable(Of String)-Interface gar nicht implementiert. Ich habe das jetzt einfach mal über eine Überprüfung auf IEnumerable gelöst, deren Inhalt auf Strings überprüft wird. Wenn mindestens ein String enthalten ist, wird sie als gültig angesehen, ansonsten nicht. Aus Performancegründen habe ich außerdem DragEnter und DragOver getrennt. DragEnter überprüft ab sofort auf die Gültigkeit der Daten, während in DragOver nur noch die Modifizierer behandelt werden. Das bedeutet, man muss ab sofort DragEnter vor DragOver aufrufen, wenn man selber Gebrauch von den OnDragEnter-, OnDragOver- oder OnDragDrop-Methoden macht.
      Ich gehe übrigens immer davon aus, dass der Drag-Drop-Mechanismus der Quellanwendung korrekt implementiert wird und den Normen folgt. Wenn also jmd. auf die Idee kommt URIs zu Draggen, funktioniert das nicht, weil URIs eine andere Syntax haben, als Dateinamen. Daher wird auch nicht auf die Gültigkeit der Dateinamen eingegangen (das darf dürft dann ihr implementieren, wenn ihr den Code verwendet und das sicherstellen wollt).

      Gruß
      ~blaze~

      Fortsetzung: Drag-Quelle implementieren

      Bisher wurde ja nur gezeigt, wie Listbox und Textbox einzurichten sind, will man aus beliebiger Anwendung heraus was drauf droppen.
      Jetzt aber wird die Listbox zusätzlich als Quelle von D&D eingerichtet.

      An Funktionalität verlangt dieses:
      • Der Drag-Vorgang ist zu starten, wenn mit gedrückter Maustaste ein kleines Stück gezogen wurde. Das ist wichtig, damit nicht bei jedem MouseDown ein D&D-Vorgang startet, denn MousDown ereignet sich ja auch bei Klick und Doppelklick, wenn also D&D garnet gemeint ist.
      • Nach Abschluß des Draggens kann (muß nicht) eine Auswertung des zurückgegebenen DropEffekts erfolgen, zB. bei DropEffekt.Move kann das Quell-Item aus der Quell-Auflistung gelöscht werden, im Unterschied zu DropEffekt.Copy, bei dem das Quell-Item nur kopiert wird, und also in der Quelle verbleibt.

      Der Code:

      VB.NET-Quellcode

      1. Public Class frmDragDropSample
      3. Private _GrabOffset As Size
      4. Private Const _Tolerance As Double = 5 ^ 2
      6. #Region "receive Drop"
      8. Private Sub Control_DragOver(ByVal sender As Object, ByVal e As DragEventArgs) _
      9. Handles ListBox1.DragOver, TextBox1.DragOver
      10. 'erlaubte DropEffects festlegen
      11. Dim eff = If(Control.ModifierKeys.HasFlag(Keys.Control), DragDropEffects.Copy, DragDropEffects.Move)
      12. Select Case True
      13. Case sender Is ListBox1
      14. If TypeOf e.Data.GetData(DataFormats.FileDrop) Is IEnumerable(Of String) Then e.Effect = e.AllowedEffect And eff
      16. Case sender Is TextBox1
      17. If TypeOf e.Data.GetData(DataFormats.Text) Is String Then e.Effect = e.AllowedEffect And eff
      18. End Select
      19. End Sub
      21. Private Sub Control_DragDrop(ByVal sender As Object, ByVal e As DragEventArgs) _
      22. Handles TextBox1.DragDrop, ListBox1.DragDrop
      23. 'auf Datenempfang reagieren
      24. Select Case True
      25. Case sender Is TextBox1
      26. 'zum Testen kann Text aussm VS-Editor auf die Textbox gezogen werden
      27. Dim txt As String = DirectCast(e.Data.GetData(DataFormats.Text), String)
      28. TextBox1.AppendText(txt & Environment.NewLine)
      30. Case sender Is ListBox1
      31. 'zum Testen können Dateien/Ordner aussm DateiBrowser auf die ListBox gezogen werden
      32. For Each fl As String In DirectCast(e.Data.GetData(DataFormats.FileDrop), IEnumerable(Of String))
      33. ListBox1.Items.Add(fl)
      34. Next
      35. End Select
      36. lbLastAction.Text = String.Concat("drop item(s) on ", sender.GetType.Name, ", with DropEffect.", e.Effect)
      37. End Sub
      38. #End Region 'receive Drop
      40. #Region "send DragDrop"
      41. Private Sub ListBox1_MouseDown(ByVal sender As Object, ByVal e As MouseEventArgs) Handles ListBox1.MouseDown
      42. If e.Button = MouseButtons.Left Then _GrabOffset = New Size(e.Location)
      43. End Sub
      44. Private Sub ListBox1_MouseMove(ByVal sender As Object, ByVal e As MouseEventArgs) Handles ListBox1.MouseMove
      45. If Not e.Button.HasFlag(MouseButtons.Left) Then Return
      46. With e.Location - _GrabOffset
      47. If .X ^ 2 + .Y ^ 2 > _Tolerance Then
      48. PerformDragFileItem(Point.Empty + _GrabOffset)
      49. End If
      50. End With
      51. End Sub
      53. Private Sub PerformDragFileItem(ByVal pt As Point)
      54. Dim indx = ListBox1.IndexFromPoint(pt)
      55. If indx < 0 Then Return
      56. Dim file = DirectCast(ListBox1.Items(indx), String)
      57. Dim dto = New DataObject(DataFormats.FileDrop, {file}) 'DataObject mit FileDropList
      58. dto.SetData(DataFormats.StringFormat, file) 'Daten zusätzlich außerdem als Text einpacken
      59. Dim allowed = DragDropEffects.Copy Or DragDropEffects.Move
      60. If ListBox1.DoDragDrop(dto, allowed) = DragDropEffects.Move Then
      61. ListBox1.Items.RemoveAt(indx)
      62. End If
      63. End Sub
      64. #End Region 'send DragDrop
      66. End Class
      Die Receive-Drop-Region ist im wesentlichen bekannt - wurde aber erweitert, um verschiedene DropEffects festlegen zu können - zeile #10:

      VB.NET-Quellcode

      1. Dim eff = If(Control.ModifierKeys.HasFlag(Keys.Control), DragDropEffects.Copy, DragDropEffects.Move)
      In eff wird ein DropEffekt erstellt, entweder DragDropEffects.Copy oder .Move, je nachdem, ob die Control-Taste (Keys.Control) gedrückt ist.

      VB.NET-Quellcode

      1. Select Case True
      2. Case sender Is ListBox1
      3. If TypeOf e.Data.GetData(DataFormats.FileDrop) Is IEnumerable(Of String) Then e.Effect = e.AllowedEffect And eff
      Bei der Listbox wird nun nicht mehr auf Vorhandensein des FileDrop-Datenformats getestet, sondern die Daten werden tatsächlich abgerufen, und getestet, ob sie einen für die Verarbeitung tauglichen Datentypen aufweisen. Ich denke, sicherer kann mans nicht machen - die externe Quell-Anwendung kann jetzt die dollsten Kapriolen implementiert haben - ein DropEffekt wird nur dann gesetzt, wenn die Daten auch wirklich verwendbar sind.
      Und gesetzt wird vorgenanntes eff, also entweder .Copy oder .Move, und wird zusätzlich mit dem durch die Eventargs vorgegebenen AllowedEffects ver-undet (e.Effect = e.AllowedEffect And eff), sodaß DragDropEffect.None gesetzt wird, falls zb. eff .Move aufweist, .Move aber garnet zu den erlaubten Effekten gehört.

      Die DragDrop-Methode ist noch weniger modifiziert - als DropEffekt-spezifische Reaktion habe ich einfach zugefügt, dass der angekommene DropEffekt im StatusLabel notiert wird (lbLastAction - zeile#36).

      Nun aber die DragDrop-Quell-Region. Betrachte nochmal den ersten Punkt der erforderlichen Funktionalität: Draggen erst, wenn mit gehaltener Maustaste ein kleines Stück gezogen wurde. Das "Kleine Stück" habe ich als _Tolerance eingeführt, und ist das Quadrat der Distanz zwischen _GrabOffset und e.Location. So kann man mit Pythagoras sehr effizient testen, wann genau ein Drag-Vorgang gemeint ist.

      VB.NET-Quellcode

      1. Private Sub ListBox1_MouseDown(ByVal sender As Object, ByVal e As MouseEventArgs) Handles ListBox1.MouseDown
      2. If e.Button = MouseButtons.Left Then _GrabOffset = New Size(e.Location)
      3. End Sub
      4. Private Sub ListBox1_MouseMove(ByVal sender As Object, ByVal e As MouseEventArgs) Handles ListBox1.MouseMove
      5. If Not e.Button.HasFlag(MouseButtons.Left) Then Return
      6. With e.Location - _GrabOffset
      7. If .X ^ 2 + .Y ^ 2 > _Tolerance Then
      8. PerformDragFileItem(Point.Empty + _GrabOffset)
      9. End If
      10. End With
      11. End Sub
      Beachte, dass _GrabOffset praktischerweise als Size deklariert ist, nicht als Point, denn eine Size kann man von einem Point direkt subtrahieren, um den Positions-Unterschied von e.Location und _GrabOffset zu erhalten (zeile #6).

      Jo, und dann wird PerformDragFileItem() aufgerufen:

      VB.NET-Quellcode

      1. Private Sub PerformDragFileItem(ByVal pt As Point)
      2. Dim indx = ListBox1.IndexFromPoint(pt)
      3. If indx < 0 Then Return
      4. Dim file = DirectCast(ListBox1.Items(indx), String)
      5. Dim dto = New DataObject(DataFormats.FileDrop, {file}) 'DataObject mit FileDropList
      6. dto.SetData(DataFormats.StringFormat, file) 'Daten zusätzlich außerdem als Text einpacken
      7. Dim allowed = DragDropEffects.Copy Or DragDropEffects.Move
      8. If ListBox1.DoDragDrop(dto, allowed) = DragDropEffects.Move Then
      9. ListBox1.Items.RemoveAt(indx)
      10. End If
      11. End Sub
      Es wird der Index des Items unter dem Point ermittelt, und abgebrochen, wenn da nix drunner ist.
      Dann wird ein DataObject erstellt, mit zweifacher Befüllung: Einmal als FileDrop-Liste, und einmal als Text. Dann wird als AllowedEffect .Copy und .Move angegeben, und dann der D&D-Vorgang mit Listbox1.DoDragDrop() abgefahren.
      Dabei wird aber der Rückgabewert ausgewertet, und falls der D&D-Vorgang sich als .Move-Vorgang erweist, wird aus der Listbox das QuellItem entfernt (zeile #9).

      Jo, ihr könnt son ListboxItem auch auf euern Explorer draggen - meiner jdfs. nimmt diese Aktion an, und setzt sie um.
      D.h.: Wenn ich aus dieser Listbox eine Datei oder einen Ordner mit .Move auf den Explorer droppe, dann führt letzterer tatsächlich die .Move-Operation aus, also er verschiebt die Datei (bzw. den Ordner).
      Bisserl Vorsicht also! ;)

      Aber ebensogut könnt ihr das ListboxItem auch auf die Textbox plumpsen lassen, die wird es auch akzeptieren - das DataObject ist ja mit beiderlei Formaten befüllt.
      Dateien

      Dieser Beitrag wurde bereits 3 mal editiert, zuletzt von „ErfinderDesRades“ ()

      Draggen innerhalb der Anwendung (DiA)

      Draggen innerhalb der Anwendung ist eine sehr andere Baustelle. Genau genommen ists ein FehlDesign, dass DiA mit derselben DoDragDrop()-Methode gestartet werden muss wie anwendungsübergreifendes Dragging.
      Diese Methode erzwingt die Angabe eines DataObjekts, was ganzngar unnötig ist, und jedermann denken macht (und programmieren), dass beim DiA Daten von einem Ort zum anderen zu transportieren seien.
      Dem ist nämlich nicht so.
      Da beim DiA so gut wie immer sowohl Start- als auch Ziel-Control bekannt sind erübrigt es sich, im StartControl die Daten ins DataObjekt zu stopfen und im ZielControl wieder auszupuhlen, mit all den Fußangeln, die das mit sich bringt.
      Stattdessen sollte man den Drag-Vorgang auffassen als eine Mausgeste, die von einem Punkt über dem StartControl zu einem Punkt über dem ZielControl führt, zuzüglich eines DropEffects, der aussagt, ob kopieren, verschieben, canceln etc.. Aber mehr ist es nicht: nur eine Geste - kein Daten-Transport.
      Nach Abschluss dieser Geste kann man die Daten dann aus dem StartControl holen, und im ZielControl einpflegen, an der richtigen Ziel-Maus-Position.
      Also nix mit DataObject und rein und raus da.

      Auch das DragDrop-Event ist beim DiA ein überflüssiger Kropf.
      Wesentlich gradlieniger ist, wenn das Draggen genau dort zum Abschluss gebracht wird, wo es auch gestartet wurde, und zwar durch direkten Aufruf der Methode, die die Bedeutung der Geste umsetzt (ich nenne sie "PerformDropped").
      Dazu braucht es kein Extra-Event.

      Also ich fasse zusammen:
      • Man braucht das StartControl.MouseDown-Event, um den Startpunkt zu identifizieren.
      • Dragging wird nicht im MouseDown gestartet, sondern erst, wenn mit gehaltener Maustaste ein kleines Stück gezogen wurde.
      • Im StartControl.MouseMove detekted und startet man den DragVorgang.
      • Da die DoDragDrop-Methode so lange wartet, bis das Dragging beendet ist, kann gleich anschließend - also noch im MouseMove! - die PerformDropped-Methode aufgerufen werden.
      • Im ZielControl.DragOver-Event wird während des Draggens der DragDropEffect festgelegt, also ob die Daten kopiert werden sollen, verschoben, oder noch was anderes.
      • Ein besonders kniffliges Problem dabei ist, die Ziel-Zone zu highlighten, denn wenn der User zB nicht genau sehen kann, zwischen welche beiden ListboxItems seine Daten eingefügt werden, dann ist ein gut Teil der Intuitivität des Draggens wieder beim Deibel.

      Hier mal die Grund-Struktur, allerdings mit suboptimal gelöstem Highlighting der Ziel-Zone:
      Aber zuvor noch ein paar kleine Helperlein

      VB.NET-Quellcode

      1. Imports System.Runtime.CompilerServices, System.Diagnostics, System.Drawing
      3. <System.ComponentModel.EditorBrowsable(System.ComponentModel.EditorBrowsableState.Never)> _
      4. Public Module Extensions
      6. ''' <summary> SquareDistance is much faster calculated than the real distance </summary>
      7. ''' <exception cref="System.OverflowException"> SqareDistance exceeds Int32.MaxValue </exception>
      8. <DebuggerStepThrough(), Extension()> _
      9. Public Function SquareDistance(ByVal pt0 As Point, ByVal pt1 As Point) As Integer
      10. With New Point(pt1.X - pt0.X, pt1.Y - pt0.Y)
      11. Return .X * .X + .Y * .Y
      12. End With
      13. End Function
      15. ''' <summary> supports a more compact notation of small ForEach-loops </summary>
      16. <DebuggerStepThrough(), Extension()> _
      17. Public Sub ForEach(Of T)(ByVal items As IEnumerable(Of T), ByVal Action As Action(Of T))
      18. For Each itm In items : Action(itm) : Next
      19. End Sub
      21. ''' <summary> more compact notation for IsNothing-Tests </summary>
      22. <DebuggerStepThrough(), Extension()> _
      23. Public Function Null(Of T As Class)(ByVal Subj As T) As Boolean
      24. Return Subj Is Nothing
      25. End Function
      27. ''' <summary> more compact notation for IsNot-Nothing-Tests </summary>
      28. <DebuggerStepThrough(), Extension()> _
      29. Public Function NotNull(Of T As Class)(ByVal Subj As T) As Boolean
      30. Return Subj IsNot Nothing
      31. End Function
      33. Private _Counter As Integer
      35. ''' <summary> eases doing Debug-Output </summary>
      36. Public Sub Dbg(ByVal ParamArray msgSegments() As Object)
      37. Console.WriteLine(_Counter & " " & String.Join(" ", msgSegments))
      38. _Counter = (_Counter + 1) Mod 10
      39. End Sub
      41. End Module

      VB.NET-Quellcode

      1. Private Shared _DragStart As Point, _DummiData As New DataObject
      3. Public Sub New()
      4. InitializeComponent()
      5. PrepareData()
      6. End Sub
      8. Private Sub PrepareData()
      9. '2 Dgv-Spalten und viele Treeview-Nodes sind bereits im Designer angelegt
      10. Enumerable.Range(0, 3).Select(Function(i) {"Column1." & i, "Column2." & i}).ForEach(AddressOf DataGridView1.Rows.Add)
      11. TreeView1.ExpandAll()
      12. TreeView1.Sorted = True
      13. TreeView1.HideSelection = False
      14. End Sub
      16. Private Sub DataGridView1_MouseDown(ByVal sender As Object, ByVal e As MouseEventArgs) Handles DataGridView1.MouseDown
      17. If e.Button <> Windows.Forms.MouseButtons.Left Then Return
      18. _DragStart = e.Location
      19. End Sub
      21. ''' <summary>
      22. ''' Bei ziehen über 3 pix Draggen starten und mit dem Ergebnis PerformDragDrop aufrufen
      23. ''' </summary>
      24. Private Sub DataGridView1_MouseMove(ByVal sender As Object, ByVal e As MouseEventArgs) Handles DataGridView1.MouseMove
      25. If e.Button <> Windows.Forms.MouseButtons.Left Then Return
      26. With e.Location ' draggen erst bei Ziehen über 3 Pix ( Quadrat-Distanz > 9 )
      27. If (_DragStart.X - .X) ^ 2 + (_DragStart.Y - .Y) ^ 2 <= 9 Then Return
      28. End With
      29. Dim result = DataGridView1.DoDragDrop(_DummiData, DragDropEffects.Copy Or DragDropEffects.Link Or DragDropEffects.Move Or DragDropEffects.Scroll)
      30. If result <> DragDropEffects.None Then PerformTreeviewDrop(result)
      31. End Sub
      33. ''' <summary> DropEffect wählen von: .None, .Move, .Link, ggfs. Ziel-Node selecten</summary>
      34. Private Sub TreeView1_DragOver(ByVal sender As Object, ByVal e As DragEventArgs) Handles TreeView1.DragOver
      35. Select Case Control.ModifierKeys
      36. Case Keys.None
      37. e.Effect = DragDropEffects.Move
      38. Case Keys.Shift
      39. e.Effect = DragDropEffects.Link
      40. End Select
      41. Dim nd = TreeView1.GetNodeAt(TreeView1.PointToClient(Control.MousePosition))
      42. TreeView1.SelectedNode = nd
      43. End Sub
      45. ''' <summary> DgvCell-Text in Treeview hängen - ggfs. DgvCell-Text löschen </summary>
      46. Private Sub PerformTreeviewDrop(ByVal result As DragDropEffects)
      47. Dim nd = TreeView1.GetNodeAt(TreeView1.PointToClient(Control.MousePosition))
      48. Dim nodes = If(nd.Null, TreeView1.Nodes, nd.Nodes)
      49. Dim cell = DataGridView1.SelectedCells(0)
      50. Select Case result
      51. Case DragDropEffects.Copy
      52. nodes.Add(cell.Value.ToString)
      53. Case DragDropEffects.Move
      54. nodes.Add(cell.Value.ToString)
      55. cell.Value = ""
      56. End Select
      57. If nd.NotNull Then nd.Expand()
      58. End Sub
      Dieses Sample draggt die selektierte Dgv-Zelle in einen Treenode.
      Vlt irre ich mich, aber mir ist, als sei gar nichts zu erläutern - steht ja alles da.

      Ah - hinzuweisen ist darauf, dass Controls es ganz unterschiedlich umsetzen, wenns drum geht, das grade unter der Maus befindliche Item zu identifizieren:
      Beim Treeview ists die .GetNodeAt()-Methode und beim ListView heißts .GetItemAt(). Hingegen Listbox.IndexFromPoint() liefert gar kein Item, sondern nur den Index, und DatagridView.HitTest() liefert gleich ein Bündel an Informationen zur Auswertung an.

      Dieser Beitrag wurde bereits 12 mal editiert, zuletzt von „ErfinderDesRades“ ()

      Ja, obiges hübsches Sample hat den gravierenden Nachteil, dass der Ziel-Bereich nur ungenügend highlighted wird: Soll nämlich auf oberster Treeview-Ebene eingehängt werden, so kann kein Ziel-Node selectiert werden.
      Ausserdem löst das Verstellen der Selection natürlich das Treeview.AfterSelect-Event aus, an welches in anspruchsvollen Oberflächen meist weitere umfangreiche Funktionalität angehängt ist.
      Das wird ganz schön rumklappern, wenn der User über verschiedene Nodes fährt.

      Daher muss ein ownerdrawn Highlighting her, welches einfach ein Rechteck auf dem Bildschirm hervorheben kann, ohne in irgendeiner Weise sonst in die Anwendungslogik einzugreifen.
      Ich habe das mit einigen Extensions gelöst, und wo ich schon dabei war, habe ich das StartControl_MouseMove gleich mit hineingenommen, denn das ist auch recht komplex, dabei immer dasselbe - somit klarer Kandidat fürs Auslagern wiederverwendbaren Codes.
      Der entspechende Ausschnitt aus Module DraggingX:

      VB.NET-Quellcode

      1. <System.ComponentModel.EditorBrowsable(System.ComponentModel.EditorBrowsableState.Never)> _
      2. Public Module DraggingX
      3. ' Das Highlighten erfolgt durch Farb-Inversion des Target-Rectangles. Ausschalten
      4. ' des Highlights durch wiederholte Inversion desselben Rectangles. Fehl-Highlighting
      5. ' ergibt sich also, wenn zwischen Highlight() und Off() das Rectangle anderweitig
      6. ' übermalt wurde.
      8. Private _HighlightedRect As Rectangle = Rectangle.Empty
      10. ' Farb-Inversion ist eine Art "Spiegelung" über eine Farb-Achse.
      11. ' Dieses komische Rot ergibt (bisher) immer deutliche "Spiegel-Farben"
      12. Private ReadOnly _AxisColor As Color = Color.FromArgb(255, 0, 127)
      13. Private _DragEventNone As New DragEventArgs(Nothing, Nothing, Nothing, Nothing, Nothing, Nothing)
      14. Private _DummiData As New DataObject, _AllAllowed As DragDropEffects = DragDropEffects.Copy Or DragDropEffects.Link Or DragDropEffects.Move Or DragDropEffects.Scroll
      15. Private _Target As Control, _Callback As Action(Of DragDropEffects), _DragStart As Point, _DragMouseButton As MouseButtons
      16. Private WithEvents _Origin As Control
      18. <DebuggerStepThrough(), Extension()> _
      19. Public Function DragOrigin(ByVal target As Control) As Control
      20. Return _Origin
      21. End Function
      22. <DebuggerStepThrough(), Extension()> _
      23. Public Function DragTarget(ByVal origin As Control) As Control
      24. Return _Target
      25. End Function
      27. <Extension()> _
      28. Public Sub ListenForDragging(ByVal origin As Control, ByVal callback As Action(Of DragDropEffects))
      29. _Origin = origin
      30. _DragMouseButton = Control.MouseButtons
      31. _Callback = callback
      32. _DragStart = _Origin.PointToClient(Control.MousePosition)
      33. End Sub
      35. Private Sub Origin_MouseMove(ByVal sender As Object, ByVal e As MouseEventArgs) Handles _Origin.MouseMove
      36. If e.Button <> _DragMouseButton Then Return
      37. If e.Location.SquareDistance(_DragStart) > 9 Then ' erst draggen, wenn 3 pix mit gehaltener Maus gezogen wurde
      38. Dim result = _Origin.DoDragDrop(_DummiData, _AllAllowed) ' DoDragDrop kehrt erst nach Ende des Drag-Vorgangs zurück
      39. If result <> DragDropEffects.None Then
      40. _Callback(result) ' ggfs den callback rufen
      41. _Target.Highlight(Nothing) ' HighLight löschen
      42. End If
      43. _Origin = Nothing
      44. End If
      45. End Sub
      46. '...
      In diesem Modul werden viele Variablen gehalten - insbesondere _DummiData und _DragStart kann nun aus dem Form-Code herausgehalten werden.
      In ListenForDragging() werden diese initialisiert, vor allem der _Callback, mit dem das Modul die "PerformDrop"-Methode im Form zurückrufen kann, wenn das Dragging ein Ergebnis erzielt.

      Das komplette DraggingX-Modul gibts nur im Spoiler, und erkläre ich auch nur im Ansatz:
      Das Highlighting beruht auf der ControlPaint.FillReversibleRectangle()-Methode, und es muss recht trickreich verwaltet werden, ob und welches Rechteck auffm Bildschirm grade invertiert ist, und obs zurück-invertiert werden muss.
      Weitere Komplexität ergibt sich durch die vielfältigen Anforderungen: Das Highlighting muss beim Treeview zB das Item selbst highlighten können, aber zb. bei Listbox muss er auch zwischen zwei Item highlighten können, aber auch hinter einem Item, und auch einen Bereich in einem ganz leeren Control.
      ausgelagerte komplexe Funktionalität für DragStart und Highlighting

      VB.NET-Quellcode

      1. Imports System.Runtime.CompilerServices, System.Diagnostics, System.Drawing, System.Windows.Forms
      3. <System.ComponentModel.EditorBrowsable(System.ComponentModel.EditorBrowsableState.Never)> _
      4. Public Module DraggingX
      5. ' Das Highlighten erfolgt durch Farb-Inversion des Target-Rectangles. Ausschalten
      6. ' des Highlights durch wiederholte Inversion desselben Rectangles. Fehl-Highlighting
      7. ' ergibt sich also, wenn zwischen Highlight() und Off() das Rectangle anderweitig
      8. ' übermalt wurde.
      10. Private _HighlightedRect As Rectangle = Rectangle.Empty
      12. ' Farb-Inversion ist eine Art "Spiegelung" über eine Farb-Achse.
      13. ' Dieses komische Rot ergibt (bisher) immer deutliche "Spiegel-Farben"
      14. Private ReadOnly _AxisColor As Color = Color.FromArgb(255, 0, 127)
      15. Private _DragEventNone As New DragEventArgs(Nothing, Nothing, Nothing, Nothing, Nothing, Nothing)
      16. Private _DummiData As New DataObject, _AllAllowed As DragDropEffects = DragDropEffects.Copy Or DragDropEffects.Link Or DragDropEffects.Move Or DragDropEffects.Scroll
      17. Private _Target As Control, _Callback As Action(Of DragDropEffects), _DragStart As Point, _DragMouseButton As MouseButtons
      18. Private WithEvents _Origin As Control
      20. <DebuggerStepThrough(), Extension()> _
      21. Public Function DragOrigin(ByVal target As Control) As Control
      22. Return _Origin
      23. End Function
      24. <DebuggerStepThrough(), Extension()> _
      25. Public Function DragTarget(ByVal origin As Control) As Control
      26. Return _Target
      27. End Function
      29. <Extension()> _
      30. Public Sub ListenForDragging(ByVal origin As Control, ByVal callback As Action(Of DragDropEffects))
      31. _Origin = origin
      32. _DragMouseButton = Control.MouseButtons
      33. _Callback = callback
      34. _DragStart = _Origin.PointToClient(Control.MousePosition)
      35. End Sub
      37. Private Sub Origin_MouseMove(ByVal sender As Object, ByVal e As MouseEventArgs) Handles _Origin.MouseMove
      38. If e.Button <> _DragMouseButton Then Return
      39. If e.Location.SquareDistance(_DragStart) > 9 Then ' erst draggen, wenn 3 pix mit gehaltener Maus gezogen wurde
      40. Dim result = _Origin.DoDragDrop(_DummiData, _AllAllowed) ' DoDragDrop kehrt erst nach Ende des Drag-Vorgangs zurück
      41. If result <> DragDropEffects.None Then
      42. _Callback(result) ' ggfs den callback rufen
      43. _Target.Highlight(Nothing) ' HighLight löschen
      44. End If
      45. _Origin = Nothing
      46. End If
      47. End Sub
      49. <Extension()> _
      50. Public Sub Highlight(ByVal target As Control, ByVal itemRect As Rectangle, Optional ByVal e As DragEventArgs = Nothing)
      51. Dim rct = target.ClientRectangle
      52. rct = New Rectangle(rct.X, rct.Y + 1, rct.Width, rct.Height - 1)
      53. If e.NotNull Then
      54. If Not rct.Contains(target.PointToClient(Control.MousePosition)) Then
      55. ' DragOver ausserhalb des ClientRectangles ablehnen
      56. e.Effect = DragDropEffects.None
      57. End If
      58. If e.Effect = DragDropEffects.None Then itemRect = Rectangle.Empty
      59. End If
      60. itemRect.Intersect(rct)
      61. ' FillReversibleRectangle verwendet bildschirmbezogene Koordinaten, daher muß ItemRect
      62. ' um die Bildschirmposition des Controls verschoben werden
      63. itemRect.Offset(target.PointToScreen(Point.Empty))
      64. If itemRect = _HighlightedRect Then Return ' ist schon highlighted
      65. ' altes Highlight löschen und neues Highlight setzen
      66. If Not _HighlightedRect.IsEmpty Then ControlPaint.FillReversibleRectangle(_HighlightedRect, _AxisColor)
      67. _HighlightedRect = itemRect
      68. If _HighlightedRect.IsEmpty Then
      69. _Target = Nothing
      70. Else
      71. _Target = target
      72. ControlPaint.FillReversibleRectangle(_HighlightedRect, _AxisColor)
      73. End If
      74. End Sub
      76. <Extension()> _
      77. Public Sub HighlightBefore(ByVal Target As Control, ByVal e As DragEventArgs, ByVal ItemRect As Rectangle)
      78. ItemRect.Offset(0, -ItemRect.Height \ 2)
      79. ItemRect.Inflate(0, -2)
      80. Highlight(Target, ItemRect, e)
      81. End Sub
      83. <Extension()> _
      84. Public Sub HighlightAfter(ByVal Target As Control, ByVal e As DragEventArgs, ByVal ItemRect As Rectangle)
      85. ItemRect.Offset(0, ItemRect.Height)
      86. HighlightBefore(Target, e, ItemRect)
      87. End Sub
      89. <Extension()> _
      90. Public Sub HighlightFullWidth(ByVal Target As Control, ByVal e As DragEventArgs, ByVal Y As Integer, ByVal Height As Integer)
      91. 'bei leeren ListenControls, oder bei Treeview.TopLevel als Ziel kann kein ItemRect angegeben werden
      92. DraggingX.Highlight(Target, New Rectangle(0, Y, Target.Width, Height), e)
      93. End Sub
      95. End Module
      Soweit die auslager- und wiederverwend-bare Komplexität - aber leider verbleibt noch genügend komplexes zB im Listview_DragOver, denn es muss ja sorgfältig differenziert werden, ob ein Ziel-Item existiert, und ob vor oder nach diesem zu highlighten ist, oder ob ins leere Control highlighten, oder obs Highlighting aus soll.
      Aber dass _DragStart, _DummiData und der ganze ListBox1_MouseMove-Handler nun weg können, ist doch auch schon was, oder?

      VB.NET-Quellcode

      1. Public Class ListboxListview
      3. Private Sub ListBox1_MouseDown(ByVal sender As Object, ByVal e As MouseEventArgs) Handles ListBox1.MouseDown
      4. If ListBox1.SelectedItem IsNot Nothing Then ListBox1.ListenForDragging(AddressOf ListviewPerformDropped)
      5. End Sub
      7. Private Sub ListView1_DragOver(ByVal sender As Object, ByVal e As DragEventArgs) Handles ListView1.DragOver
      8. If ListView1.DragOrigin IsNot ListBox1 Then Return
      9. Select Case Control.ModifierKeys
      10. Case Keys.None
      11. e.Effect = DragDropEffects.Move
      12. Case Keys.Shift
      13. e.Effect = DragDropEffects.Copy
      14. End Select
      15. Dim pt = ListView1.PointToClient(Control.MousePosition)
      16. Dim lvi = ListView1.GetItemAt(pt.X, pt.Y)
      17. ' beim Highlighting sind 3 Varianten abzudecken - Highlight.Off erkennt er selbst
      18. If ListView1.Items.Count = 0 Then 'Highlight in leeres Listview
      19. ListView1.HighlightFullWidth(e, 16, 16)
      20. ElseIf lvi.Null Then 'Highlight hinter das letzte Item
      21. ListView1.HighlightAfter(e, ListView1.Items(ListView1.Items.Count - 1).Bounds)
      22. Else
      23. ListView1.HighlightBefore(e, lvi.Bounds) 'Highlight vor dem Ziel-Item
      24. End If
      25. End Sub
      27. Private Sub ListviewPerformDropped(ByVal result As DragDropEffects)
      28. Dim pt = ListView1.PointToClient(Control.MousePosition)
      29. Dim lvi = ListView1.GetItemAt(pt.X, pt.Y)
      30. Dim indx = If(lvi.Null, ListView1.Items.Count, lvi.Index)
      31. Dim txt = DirectCast(ListBox1.SelectedItem, String)
      32. Select Case result
      33. Case DragDropEffects.Move
      34. ListView1.Items.Insert(indx, txt)
      35. ListBox1.Items.RemoveAt(ListBox1.SelectedIndex)
      36. Case DragDropEffects.Copy
      37. ListView1.Items.Insert(indx, txt)
      38. End Select
      39. End Sub
      41. End Class

      Dieser Beitrag wurde bereits 5 mal editiert, zuletzt von „ErfinderDesRades“ ()

      Das ItemDrag ist so ziemlich ListView-eigen.
      Bei einer LisBox ist das so nicht möglich.
      Dazu hab ich bei CodeProject ein älteres konvertierungsbedürftiges Projekt gefunden, hier das im Prinzip komplette Projekt
      (der Designer-Code und der Form-Code müssen separat in eine neue FormX.cs bzw. FormX.Designer.cs kopiert werden.
      Das Beispiel drag-dropt Strings von einer ListBox in eine andere und auch in eine Notepad-Instanz.
      Spoiler anzeigen

      C#-Quellcode

      1. using System;
      2. using System.Windows.Forms;
      4. namespace DragDropNish
      5. {
      6. /// <summary>
      7. /// Summary description for Form1.
      8. /// </summary>
      9. public class Form1 : System.Windows.Forms.Form
      10. {
      11. private System.Windows.Forms.ListBox listBox1;
      12. private System.Windows.Forms.ListBox listBox2;
      13. private System.Windows.Forms.Label label1;
      14. /// <summary>
      15. /// Required designer variable.
      16. /// </summary>
      17. private System.ComponentModel.Container components = null;
      19. public Form1()
      20. {
      21. //
      22. // Required for Windows Form Designer support
      23. //
      24. this.InitializeComponent();
      26. this.listBox1.Items.Add("Nish [BusterBoy]");
      27. this.listBox1.Items.Add("Colin Davies");
      28. this.listBox1.Items.Add("Paul Watson");
      30. this.listBox1.Items.Add("David Wulff");
      31. this.listBox1.Items.Add("Christian Graus");
      32. this.listBox1.Items.Add("Chris Maunder");
      34. this.listBox1.Items.Add("Tweety");
      35. this.listBox1.Items.Add("Qomi");
      36. this.listBox1.Items.Add("Lauren");
      38. //
      39. // TODO: Add any constructor code after InitializeComponent call
      40. //
      41. }
      43. /// <summary>
      44. /// Clean up any resources being used.
      45. /// </summary>
      46. protected override void Dispose(bool disposing)
      47. {
      48. if (disposing)
      49. {
      50. if (this.components != null)
      51. {
      52. this.components.Dispose();
      53. }
      54. }
      55. base.Dispose(disposing);
      56. }
      58. #region Windows Form Designer generated code
      59. /// <summary>
      60. /// Required method for Designer support - do not modify
      61. /// the contents of this method with the code editor.
      62. /// </summary>
      63. private void InitializeComponent()
      64. {
      65. this.listBox1 = new System.Windows.Forms.ListBox();
      66. this.listBox2 = new System.Windows.Forms.ListBox();
      67. this.label1 = new System.Windows.Forms.Label();
      68. this.SuspendLayout();
      69. //
      70. // listBox1
      71. //
      72. this.listBox1.Font = new System.Drawing.Font("Microsoft Sans Serif", 14F, System.Drawing.FontStyle.Regular, System.Drawing.GraphicsUnit.Point, 0);
      73. this.listBox1.ItemHeight = 24;
      74. this.listBox1.Location = new System.Drawing.Point(32, 16);
      75. this.listBox1.Name = "listBox1";
      76. this.listBox1.Size = new System.Drawing.Size(176, 196);
      77. this.listBox1.TabIndex = 0;
      78. this.listBox1.MouseDown += new System.Windows.Forms.MouseEventHandler(this.listBox1_MouseDown);
      79. //
      80. // listBox2
      81. //
      82. this.listBox2.AllowDrop = true;
      83. this.listBox2.Font = new System.Drawing.Font("Microsoft Sans Serif", 14F, System.Drawing.FontStyle.Regular, System.Drawing.GraphicsUnit.Point, 0);
      84. this.listBox2.ItemHeight = 24;
      85. this.listBox2.Location = new System.Drawing.Point(344, 16);
      86. this.listBox2.Name = "listBox2";
      87. this.listBox2.Size = new System.Drawing.Size(176, 196);
      88. this.listBox2.TabIndex = 1;
      89. this.listBox2.DragOver += new System.Windows.Forms.DragEventHandler(this.listBox2_DragOver);
      90. this.listBox2.DragDrop += new System.Windows.Forms.DragEventHandler(this.listBox2_DragDrop);
      91. //
      92. // label1
      93. //
      94. this.label1.BorderStyle = System.Windows.Forms.BorderStyle.FixedSingle;
      95. this.label1.Font = new System.Drawing.Font("Microsoft Sans Serif", 13F, System.Drawing.FontStyle.Regular, System.Drawing.GraphicsUnit.Point, 0);
      96. this.label1.Location = new System.Drawing.Point(88, 224);
      97. this.label1.Name = "label1";
      98. this.label1.Size = new System.Drawing.Size(328, 40);
      99. this.label1.TabIndex = 2;
      100. this.label1.Text = "Drag and drop names from the list box on the left to the list box on the right";
      101. this.label1.TextAlign = System.Drawing.ContentAlignment.MiddleCenter;
      102. //
      103. // Form1
      104. //
      105. this.AutoScaleBaseSize = new System.Drawing.Size(5, 13);
      106. this.ClientSize = new System.Drawing.Size(568, 278);
      107. this.Controls.AddRange(new System.Windows.Forms.Control[] {
      108. this.label1,
      109. this.listBox2,
      110. this.listBox1});
      111. this.FormBorderStyle = System.Windows.Forms.FormBorderStyle.FixedDialog;
      112. this.MaximizeBox = false;
      113. this.Name = "Form1";
      114. this.Text = "Playing with drag and drop";
      115. this.ResumeLayout(false);
      117. }
      118. #endregion
      120. /// <summary>
      121. /// The main entry point for the application.
      122. /// </summary>
      123. [STAThread]
      124. private static void Main()
      125. {
      126. Application.Run(new Form1());
      127. }
      129. private void listBox1_MouseDown(object sender, System.Windows.Forms.MouseEventArgs e)
      130. {
      131. if (this.listBox1.Items.Count == 0)
      132. {
      133. return;
      134. }
      136. string s = this.listBox1.Items[this.listBox1.IndexFromPoint(e.X, e.Y)].ToString();
      137. DragDropEffects dde1 = this.DoDragDrop(s, DragDropEffects.All);
      139. if (dde1 == DragDropEffects.All)
      140. {
      141. this.listBox1.Items.RemoveAt(this.listBox1.IndexFromPoint(e.X, e.Y));
      142. }
      143. }
      145. private void listBox2_DragDrop(object sender, System.Windows.Forms.DragEventArgs e)
      146. {
      147. if (e.Data.GetDataPresent(DataFormats.StringFormat))
      148. {
      149. string str = (string)e.Data.GetData(DataFormats.StringFormat);
      150. this.listBox2.Items.Add(str);
      151. }
      153. }
      155. private void listBox2_DragOver(object sender, System.Windows.Forms.DragEventArgs e)
      156. {
      157. e.Effect = DragDropEffects.All;
      158. }
      159. }
      160. }


      ausgelagert aus Drag & Drop von Dateien aus einer Anwendung (Listview) in das Windows-Explorer-Dateisystem ~VaporiZed
      Falls Du diesen Code kopierst, achte auf die C&P-Bremse.
      Jede einzelne Zeile Deines Programms, die Du nicht explizit getestet hast, ist falsch :!:
      Ein guter .NET-Snippetkonverter (der ist verfügbar).
      Programmierfragen über PN / Konversation werden ignoriert!

      Dieser Beitrag wurde bereits 1 mal editiert, zuletzt von „VaporiZed“ ()

      @RodFromGermany

      Dein Code ist doch recht lang .
      Da würde ich auf eher auf die Listbox verzichten und ein Listview dafür verwenden. Codemässig weniger und der Effekt für den Nutzer identisch.
      Liebe Grüße
      Roland Berghöfer

      Meine aktuellen und kostenlos verwendbaren Tools (mit VB.NET erstellt): freeremarkabletools.com | priconman.com | SimpleCalendar | AudibleTouch | BOComponent.com | bonit.at

      dive26 schrieb:

      Dein Code ist doch recht lang .
      Dem muss ich widersprechen.
      Du hast offensichtlich den Aufbau dieses uralten Dateiformats noch nicht durchdrungen. ;)
      Für Dich relevant wäre dieser Code:
      Spoiler anzeigen

      C#-Quellcode

      1. private void listBox1_MouseDown(object sender, System.Windows.Forms.MouseEventArgs e)
      2. {
      3. if (this.listBox1.Items.Count == 0)
      4. {
      5. return;
      6. }
      7. string s = this.listBox1.Items[this.listBox1.IndexFromPoint(e.X, e.Y)].ToString();
      8. DragDropEffects dde1 = this.DoDragDrop(s, DragDropEffects.All);
      9. if (dde1 == DragDropEffects.All)
      10. {
      11. this.listBox1.Items.RemoveAt(this.listBox1.IndexFromPoint(e.X, e.Y));
      12. }
      13. }
      14. private void listBox2_DragDrop(object sender, System.Windows.Forms.DragEventArgs e)
      15. {
      16. if (e.Data.GetDataPresent(DataFormats.StringFormat))
      17. {
      18. string str = (string)e.Data.GetData(DataFormats.StringFormat);
      19. this.listBox2.Items.Add(str);
      20. }
      21. }
      22. private void listBox2_DragOver(object sender, System.Windows.Forms.DragEventArgs e)
      23. {
      24. e.Effect = DragDropEffects.All;
      25. }
      Falls Du diesen Code kopierst, achte auf die C&P-Bremse.
      Jede einzelne Zeile Deines Programms, die Du nicht explizit getestet hast, ist falsch :!:
      Ein guter .NET-Snippetkonverter (der ist verfügbar).
      Programmierfragen über PN / Konversation werden ignoriert!

      Tja, diese LösungB für Draggen innerhalb der Anwendung (DiA) fällt aber qualitativ um einiges hinter der in post#9 vorgestellten LösungA zurück:
      1. LösungB startet beim MouseDown sofort den Drag-Vorgang.
        Das entspricht nicht der üblichen und sinnvollen Maus-Geste zum Starten eines Drag-Vorgangs: Man muss nämlich mit gehaltener Taste erst ein paar Pixel ziehen.
        Ohne diese Zusatzbedingung kommt es zu zuvielen (abgebrochenden) Drag-Vorgängen, und vor allem zu Konflikten, wenn man das MouseDown-Event für etwas anderes nutzen möchte.
      2. LösungB startet ausserdem einen anwendungs-übergreifenden Drag-Vorgang, der aber gleichzeitig auch Drops von anderen Anwendungen auf Listbox2 zulässt.
        Es ist also beides: sowohl DiA als auch anwendung-übergreifend - und diese Vermischung ist wohl nur in den seltensten Fällen gewollt.
        Es ergibt sich ein für DiA unerwünschtes Verhalten, wenn von Listbox1 in eine andere Anwendung gedraggt wird.
        Noch fataler wohl in Gegenrichtung: ZB irgendwelche (auch seiten-lange) Word-Texte können nun in listBox2 gedropt werden.
      Diesen Unerfreulichkeiten ist durch die DiA-Lösung in post#9 wirkungsvoll begegnet.

      Dieser Beitrag wurde bereits 1 mal editiert, zuletzt von „ErfinderDesRades“ ()

    Facebook
    Telefonspende