Mit Ordnern und Dateien im TreeView arbeiten, Teil 1

2/2026, 2026, Interaktiv

Im Artikel „Ordner und Dateien in Access-Tabellen einlesen“ (www.vbentwickler.de/486) haben wir gezeigt, wie wir schnell Ordner und Dateien in Tabellen speichern, in „Dateien schnell im TreeView-Steuerelement anzeigen“ (www.vbentwickler.de/0) haben wir Techniken vorgestellt, mit denen wir die Daten dieser Tabellen performant in einem TreeView-Steuerelement präsentieren. Im vorliegenden Artikel schauen wir uns nun an, wie man in diesem TreeView-Steuerelement mit den Ordnern und Dateien arbeiten kann: Wie zeigen wir einen Ordner direkt im Windows-Explorer an? Wie öffnen wir eine Datei direkt per Doppelklick? Wie können wir Kopieren, Ausschneiden und Einfügen im TreeView nutzen? Wie benennen wir Ordner und Dateien um? Und schließlich: Wie übertragen wir diese Änderungen direkt auf das Dateisystem?

Voraussetzung

Wir bauen in diesem Artikel auf dem Beispielformular frmDateienImTreeView auf, das wir im Artikel Dateien schnell im TreeView-Steuerelement anzeigen (www.vbentwickler.de/0) bereits vorgestellt haben (siehe Bild 1).

TreeView-Steuerelement mit den Einträgen, mit denen wir arbeiten wollen

Bild 1: TreeView-Steuerelement mit den Einträgen, mit denen wir arbeiten wollen

Ordner oder Dateien direkt im Windows Explorer anzeigen

Als Erstes wollen wir uns um die Anzeige eines Ordners oder einer Datei direkt im Windows Explorer kümmern.

Diese Funktionen werden wir später in verschiedenen Kontexten aufrufen – das Anzeigen eines Ordners über das Kontextmenü und das Anzeigen einer Datei im Windows Explorer über das Kontextmenü oder per Doppelklick auf das jeweilige Datei-Element im TreeView-Steuerelement.

Ordner direkt im Windows Explorer anzeigen

Die Prozedur zum Anzeigen eines Ordners im Windows Explorer ist denkbar einfach. Wir müssen nur die Anwendung Explorer.exe aufrufen und dieser den Pfad des anzuzeigenden Ordners übergeben. Außerdem können wir noch angeben, in welchem Fenstermodus der Windows Explorer geöffnet werden soll – hier wählen wir standardmäßig die normale Ansicht.

Die Prozedur OpenFolderInExplorer nimmt den Pfad des anzuzeigenden Ordners als Parameter entgegen:

Public Sub OpenFolderInExplorer(strPath As String)
     Shell "explorer.exe """ & strPath & """", _
         vbNormalFocus
End Sub

Sie ruft die VBA-Funktion Shell auf und übergibt den in Anführungszeichen eingefassten Pfad als Parameter.

Wenn wir etwa den Pfad des aktuellen Datenbankverzeichnisses anzeigen wollen, rufen wir die Prozedur beispielsweise wie folgt auf:

Call OpenFolderInExplorer(CurrentProject.Path)

Datei direkt im Windows Explorer anzeigen

Wir können noch einen Schritt weitergehen und direkt eine Datei im Windows Explorer markieren. Die entsprechende Prozedur nennen wir ShowFileInExplorer:

Public Sub ShowFileInExplorer(strPath As String)
     Shell "explorer.exe /select,""" & strPath & """", _
         vbNormalFocus
End Sub

Sie verwendet vor der Angabe des Pfades zu der zu markierenden Datei den Parameter /select.

Diese Prozedur rufen wir beispielsweise für die aktuelle Datenbankdatei wie folgt auf:

Call ShowFileInExplorer(CurrentDb.name)

Datei mit der jeweiligen Anwendung öffnen

Die Prozedur, mit der wir eine Datei direkt in der jeweiligen Anwendung öffnen können, heißt OpenFile und verwendet die Methode FollowHyperlink des Application-Objekts:

Public Sub OpenFile(strPath As String)
     Application.FollowHyperlink strPath
End Sub

Um zum Beispiel eine Bilddatei aus dem aktuellen Datenbankverzeichnis anzuzeigen, nutzen wir den folgenden Aufruf:

Call OpenFile(CurrentProject.Path & "\pic005.png")

Angeklicktes Node-Element ermitteln

Für verschiedene Aktionen müssen wir zuvor das angeklickte Node-Element referenzieren – zum Beispiel, wenn wir eine Aktion beim Doppelklick darauf ausführen wollen.

Also deklarieren wir im Kopf des Klassenmoduls eine Variable, um das aktuelle Element zu referenzieren:

Dim objCurrentNode As MSComctlLib.Node

Wenn der Benutzer auf ein Node-Element klickt, soll dieses mit objCurrentNode referenziert werden. Wenn der Benutzer auf einen freien Bereich im TreeView-Steuerelement klickt, soll die Objektvariable objCurrentNode geleert werden.

Das erledigen wir mit der Ereignisprozedur, die beim Herunterdrücken der Maustaste ausgelöst wird. Wir legen die entsprechende Prozedur an, indem wir im Codefenster im linken Auswahlfeld den Eintrag ctlTreeView auswählen und im rechten Auswahlfeld MouseDown.

Die so angelegte Prozedur füllen wir mit den folgenden Anweisungen:

Private Sub ctlTreeView_MouseDown( _
         ByVal Button As Integer, ByVal Shift As Integer, _
         ByVal x As Long, ByVal y As Long)
     Set objCurrentNode = ctlTreeView.Object.HitTest(x, y)
     If objCurrentNode Is Nothing Then
         Me.ctlTreeView.Object.SelectedItem = Nothing
     End If
End Sub

Die Prozedur erhält mit den Parametern X und Y die beim Klicken mit der Maus gültigen Koordinaten des Mauszeigers. Diese werten wir mit der Eigenschaft HitTest aus.

Wenn der Benutzer ein Node-Element angeklickt hat, wird ein Verweis darauf zurückgeliefert. Wenn nicht, ist nicht nur objCurrentNode leer, sondern wir wollen dann auch den aktuell markierten Eintrag abwählen. Dazu stellen wir die Eigenschaft SelectedItem auf Nothing ein.

Aktuell markierte Datei per Doppelklick öffnen

Wenn wir die Funktion OpenFile per Doppelklick auf einen der Datei-Einträge im TreeView-Steuerelement aufrufen wollen, benötigen wir das Ereignis DblClick. Dieses liefert keinerlei Parameter, die eine Information über das angeklickte Node-Element enthalten.

Deshalb haben wir die zuvor erläuterte Ereignisprozedur angelegt. Klicken wir nun doppelt auf eines der Elemente, erhalten wir den Verweis auf das angeklickte Node-Element über die Objektvariable objCurrentNode. Wenn der Benutzer einen Doppelklick außerhalb der Node-Elemente durchgeführt hat, ist objCurrentNode leer.

Diese Variable werten wir in der folgenden Ereignisprozedur aus. Nur wenn objCurrentNode nicht Nothing ist, ermitteln wir den Key aus der Key-Eigenschaft und lesen darauf mit Left das erste Zeichen aus, das entweder f (Folder) oder i (File) lautet.

Der Doppelklick soll nur etwas bewirken, wenn wir eine Datei angeklickt haben – im Falle eines Doppelklicks auf einen Ordner soll nur das Standardverhalten ausgelöst werden, in diesem Fall das Aufklappen der untergeordneten Elemente.

Wir haben in den Tabellen tblFolders und tblFiles nur die Namen des jeweiligen Ordners oder der Datei gespeichert, nicht den vollständigen Pfad zum entsprechenden Element.

Deshalb müssen wir, um die doppelt angeklickte Datei zu öffnen, erst den Pfad ermitteln. Dazu nutzen wir die Funktion GetFilePath, der wir die ID der Datei aus dem Key übergeben. Nachdem wir damit den Pfad ermittelt haben, können wir die Funktion OpenFile aufrufen und mit dieser die Datei mit dem entsprechenden Pfad öffnen:

Private Sub ctlTreeView_DblClick()
     Dim strPath As String
     Dim strKey As String
     
     If Not objCurrentNode Is Nothing Then
         strKey = objCurrentNode.Key
         Select Case Left(strKey, 1)
             Case "i"
                 strPath = GetFilePath(Mid(strKey, 2))
                 Call OpenFile(strPath)
         End Select
     End If
End Sub

Pfad zu einer Datei ermitteln

Die Funktion GetFilePath erwartet die ID der Datei aus der Tabelle tblFiles (siehe Listing 1). Sie liest zunächst die ID des übergeordneten Ordners aus dem Feld ParentID der Tabelle tblFiles aus. Dann trägt sie in die Variable strPath zunächst nur den Dateinamen dieser Datei ein.

Public Function GetFilePath(ByVal lngFileID As Long) As String
     Dim lngFolderID As Long
     Dim strPath As String
     Dim strFolder As String
     lngFolderID = Nz(DLookup("ParentID", "tblFiles", "FileID = " & lngFileID), 0)
     strPath = Nz(DLookup("Filename", "tblFiles", "FileID = " & lngFileID), 0)
     Do While Not lngFolderID = 0
         strFolder = Nz(DLookup("Foldername", "tblFolders", "FolderID = " & lngFolderID), 0)
         strPath = strFolder & "\" & strPath
         lngFolderID = Nz(DLookup("ParentID", "tblFolders", "FolderID = " & lngFolderID), 0)
     Loop
     
     strPath = DLookup("Basispfad", "tblOptionen") & "\" & strPath
     GetFilePath = strPath
End Function

Listing 1: Die Funktion GetFilePath holt den Pfad zu dem Ordner oder der Datei mit der angegebenen ID.

In der folgenden Do While-Schleife, die so lange durchlaufen wird, bis es keinen übergeordneten Ordner mehr gibt (lngFolder = 0) liest die Prozedur zunächst den Namen des übergeordneten Ordners aus der Tabelle tblFolders in die Variable strFolder ein.

Dann fügt sie diesen Namen, getrennt durch einen Backslash, vorn an den Inhalt der Variablen strPath an und speichert das Ergebnis wieder in strPath. Außerdem ermittelt sie nun die ID des übergeordneten Elements für diesen Ordner aus der Tabelle tblFolders und schreibt diese in lngFolderID.

Auf diese Weise entsteht ein Pfad wie Dir03\Dir0303\Test030303.txt. Da wir die Ordner und Dateien immer von dem im Feld Basisordner der Tabelle tblOptionen aus in den Tabellen tblFolders und tblFiles speichern, müssen wir nun nur noch den dort gespeicherten Pfad hinzufügen, um den vollständigen Pfad zu erhalten.

Diesen gibt die Funktion als Ergebnis zurück.

Kontextmenü im TreeView-Steuerelement anzeigen

Wenn wir nicht nur Dateien öffnen, sondern diese und auch Ordner im Windows Explorer anzeigen wollen, benötigen wir ein Kontextmenü. Allein mit Klick-Befehlen lässt sich dies nicht so realisieren, dass es für den Benutzer noch intuitiv ist.

Also fügen wir ein Kontextmenü hinzu, das je nach Position des Klicks unterschiedliche Optionen haben soll.

Beim Klick auf einen Ordner sollen folgende Befehle erscheinen. Alle Befehle sollen später mit dem Pendant für die entsprechende Aktion im „echten“ Dateisystem ausgestattet werden:

  • Neuer Ordner: Legt einen neuen Ordner-Node namens Neuer Ordner an und aktiviert direkt das Umbenennen des neuen Ordners.
  • Ordner löschen: Löscht den Ordner-Node.
  • Ordner kopieren: Kopiert den Ordner-Node.
  • Ordner ausschneiden: Kopiert den Ordner-Node und löscht diesen, sobald er an anderer Stelle eingefügt wurde.
  • Einfügen: Fügt einen Ordner- oder Datei-Node, der zuvor kopiert oder ausgeschnitten wurde, in diesem Ordner ein.
  • Ordner im Windows Explorer öffnen: Öffnet den Ordner im Windows-Explorer.
  • Dateipfad kopieren: Kopiert den Dateipfad des Ordners in die Zwischenablage.
  • Ordner umbenennen: Versetzt das Element in den Umbenennen-Modus

Beim Klick auf eine Datei sind diese Befehle vorgesehen:

  • Datei löschen: Löscht den Node.
  • Datei kopieren: Kopiert den Node in die Zwischenablage.
  • Datei ausschneiden: Kopiert den Node in die Zwischenablage und löscht ihn, sobald dieser an anderer Stelle eingefügt wurde.
  • Datei im Explorer öffnen: Zeigt die Datei im Explorer an.
  • Datei in Zielanwendung öffnen: Öffnet die Datei in der für diese festgelegten Standardanwendung.

Und beim Klick auf den leeren Raum außerhalb der Node-Elemente bieten wir diese Befehle an:

  • Neuer Ordner: Legt einen neuen Ordner namens Neuer Ordner an und aktiviert den Umbenennen-Modus.

Kontextmenüs anlegen

Kontextmenüs legen wir auf dem herkömmlichen Wege über die CommandBars-Auflistung an. Um diese anzuzeigen, verwenden wir die MouseDown-Eigenschaft des TreeView-Steuerelements. Dazu erweitern wir die bereits vorhandene Ereignisprozedur wie in Listing 2.

Private Sub ctlTreeView_MouseDown(ByVal Button As Integer, ByVal Shift As Integer, ByVal x As Long, ByVal y As Long)
     Dim strTyp As String
     
     Set objCurrentNode = ctlTreeView.Object.HitTest(x, y)
     
     If objCurrentNode Is Nothing Then
         Me.ctlTreeView.Object.SelectedItem = Nothing
     End If
     Select Case Button
         Case acRightButton
             If Not objCurrentNode Is Nothing Then
                 strTyp = Left(objCurrentNode.Key, 1)
                 Select Case strTyp
                     Case "f"
                         Call CreateCommandBarFolder()
                     Case "i"
                         Call CreateCommandBarFile()
                 End Select
             Else
                 Call CreateCommandBarOther
             End If
     End Select
End Sub

Listing 2: Prozedur zum Aufruf der verschiedenen Kontextmenüs

Das Ergebnis soll beispielsweise für Ordner-Elemente wie in Bild 2 aussehen.

Anzeigen des Kontextmenüs für einen Ordner

Bild 2: Anzeigen des Kontextmenüs für einen Ordner

Wir ermitteln hier nach wie vor das aktuell markierte Node-Element. Dann prüfen wir, ob der Benutzer die rechte Maustaste betätigt hat (acRightButton). Ist das der Fall, prüfen wir, ob aktuell ein Node-Element markiert ist.

Falls ja, lesen wir aus der Key-Eigenschaft das erste Zeichen aus. Im Falle von f (Folder) rufen wir die Prozedur CreateCommandBarFolder auf und übergeben den Verweis auf das aktuelle Node-Element. Lautet der Buchstabe i (File), rufen wir CreateCommandBarFile auf. Falls gerade kein Node-Element markiert ist, rufen wir die Prozedur CreateCommandBarOther auf.

Kontextmenü für Ordner anzeigen

Die Prozedur CreateCommandBarFolder soll das Kontextmenü für einen Ordner anzeigen (siehe Listing 3).

Private Sub CreateCommandBarFolder()
     Dim strKey As String
     Dim cbr As Office.CommandBar
     strKey = objCurrentNode.Key
     On Error Resume Next
     CommandBars("Ordner").Delete
     On Error GoTo 0
     Set cbr = CommandBars.Add("Ordner", msoBarPopup, False, True)
     With cbr.Controls.Add(msoControlButton)
         .Caption = "Ordner kopieren"
         .OnAction = "=OrdnerKopieren(''" & strKey & "'')"
         .FaceId = 1667
     End With
     With cbr.Controls.Add(msoControlButton)
         .Caption = "Ordner ausschneiden"
         .OnAction = "=OrdnerAusschneiden(''" & strKey & "'')"
         .FaceId = 1669
     End With
     With cbr.Controls.Add(msoControlButton)
         .Caption = "Ordner einfügen"
         .OnAction = "=OrdnerEinfuegen(''" & strKey & "'')"
         .FaceId = 22
     End With
     With cbr.Controls.Add(msoControlButton)
         .Caption = "Ordner löschen"
         .OnAction = "=OrdnerLoeschen(''" & strKey & "'')"
         .FaceId = 2500
     End With
     With cbr.Controls.Add(msoControlButton)
         .Caption = "Neuer Ordner"
         .OnAction = "=NeuerOrdner(''" & strKey & "'')"
         .FaceId = 1755 ''4088 ''4274 ''2031 ''
     End With
     With cbr.Controls.Add(msoControlButton)
         .Caption = "Ordner im Windows Explorer anzeigen"
         .OnAction = "=OrdnerExplorer(''" & strKey & "'')"
         .FaceId = 32
     End With
     With cbr.Controls.Add(msoControlButton)
         .Caption = "Pfad des Ordners kopieren"
         .OnAction = "=OrdnerPfadKopieren(''" & strKey & "'')"
         .FaceId = 19
     End With    
     With cbr.Controls.Add(msoControlButton)
         .Caption = "Ordner umbenennen"
         .OnAction = "=OrdnerUmbenennen(''" & strKey & "'')"
         .FaceId = 2512
     End With
     cbr.ShowPopup
End Sub

Listing 3: Prozedur zum Anzeigen des Kontextmenüs für Ordner

Sie nimmt den Verweis auf das Node-Element entgegen, für welches das Kontextmenü angezeigt werden soll. Dann liest es die ID des Elements aus, für das es angezeigt werden soll.

Falls das Kontextmenü bereits vorhanden ist, löschen wir es bei deaktivierter Fehlerbehandlung zunächst mit der Delete-Methode.

Danach legen wir ein neues Kontextmenü namens Ordner an und legen den Typ auf msoBarPopup fest. Außerdem stellen wir den Parameter Temporary auf True ein, damit es beim Beenden der Access-Session anschließend wieder gelöscht wird

Anschließend führen wir für die zu erstellenden Kontextmenü-Einträge jeweils ähnliche Befehle aus. Wir haben uns hier aus Platzgründen entschieden, nicht wie sonst üblich für jeden Kontextmenü-Eintrag eine eigene Variable zu deklarieren, die man normalerweise zum anschließenden Zuweisen der Eigenschaften nutzt. Stattdessen nutzen wir die With-Anweisung direkt mit dem neu erstellten Element und weisen damit die drei Eigenschaften zu:

  • Caption: Erwartet die Beschriftung des Kontextmenü-Eintrags.
  • OnAction: Hier hinterlegen wir die beim Anklicken auszuführende Funktion, die wir in einem Standardmodul als öffentliche Funktion anlegen müssen.
  • FaceID: Erwartet einen Zahlenwert für ein eingebautes Menüsymbol.

Für die Eigenschaft OnAction legen wir jeweils eine Zeichenkette fest, die den Funktionsnamen enthält sowie den Key des aktuell markierten Node-Elements aus der Variablen strKey, zum Beispiel:

.OnAction = "=OrdnerKopieren(''" & strKey & "'')"

Schließlich zeigen wir das Kontextmenü mit der Methode ShowPopup an.

Funktionen für das Ordner-Kontextmenü

Das warén die einfachen Aufgaben. Nun folgen die einzelnen Funktionen, die beim Anklicken der Kontextmenü-Einträge ausgelöst werden sollen.

Diese legen wir im Standardmodul mdlKontextmenues nach dem folgenden Schema an – hier für das Kopieren eines Ordners:

Public Function OrdnerKopieren(lngID As Long)
     MsgBox "Ordner kopieren"
End Function

Wie wir diese Funktionen füllen, sehen wir in den folgenden Abschnitten.

Ordner und Datei ausschneiden, kopieren und einfügen

Was genau soll beim Ausschneiden, Kopieren und Einfügen von Ordnern geschehen? Wir wollen zunächst auf der Ebene des TreeView-Steuerelements arbeiten. Das Nachziehen der Vorgänge im Dateisystem fügen wir später hinzu.

Beim Ausschneiden und Kopieren müssen wir uns eigentlich nur die ID des jeweiligen Elements merken, da die eigentliche Aktion erst durchgeführt wird, wenn wir den Ordner an anderer Stelle einfügen.

Wie benötigen also eine öffentlich deklarierte Variable, in der wir uns merken, welches Element ausgeschnitten oder kopiert werden soll. Dazu speichern wir am besten einfach den Key des Elements in dieser Variablen. Außerdem müssen wir kenntlich machen, ob das Element mit diesem Key ausgeschnitten oder kopiert werden soll. Wir können dazu jeweils eine Variable wie strKeyOrdnerAusgeschnitten und strKeyOrdnerKopiert anlegen.

Dann müssten wir, wenn wir einen Ordner kopieren, den Key in die Variable strKeyOrdnerKopiert schreiben und die Variable strKeyOrdnerAusgeschnitten leeren und umgekehrt – wir können schließlich nur einen Einfügevorgang durchführen, also müssen wir wissen, ob gerade ein Ordner zum Ausschneiden oder Kopieren markiert wurde. Alternativ könnten wir einfach eine Variable namens strKeyAusgeschnittenOderKopiert anlegen und eine weitere Boolean-Variable, die angibt, ob ein Ordner ausgeschnitten oder kopiert werden soll. Wir entscheiden uns für die erste Variante:

Public strKeyOrdnerAusgeschnitten As String
Public strKeyOrdnerKopiert As String

Folglich hinterlegen wir für die beiden Kontextmenü-Funktionen die folgenden Anweisungen:

Public Function OrdnerKopieren(strKey As String)
     strKeyOrdnerKopiert = strKey
     strKeyOrdnerAusgeschnitten = ""
End Function
     
Public Function OrdnerAusschneiden(strKey As String)
     strKeyOrdnerKopiert = ""
     strKeyOrdnerAusgeschnitten = strKey
End Function

Einfügen eines ausgeschnittenen Ordners

Wenn wir mit der nächsten Funktion den Einfügevorgang durchführen wollen, benötigen wir Zugriff auf die TreeView-Objektvariable. Diese ziehen wir daher vom Klassenmodul in das Modul mdlGlobal und stellen die Sichtbarkeit auf Public ein:

Public objTreeview As MSComctlLib.TreeView

Wir beginnen mit dem Einfügen eines ausgeschnittenen Ordners, weil dies deutlich einfacher ist – auch wenn man es nicht glauben mag, denn das Ausschneiden besteht schließlich, oberflächlich betrachtet, aus zwei Schritten und das Kopieren scheinbar nur aus einem. Tatsächlich besteht das Ausschneiden aber nur im „Umhängen“ des Nodes an einen anderen Parent-Node.

Und, auch der Autor lernt nie aus, denn sogar das Einsortieren in die richtige Reihenfolge ist einfach: Elemente werden zwar beim Hinzufügen standardmäßig unten angehängt, und somit ist nicht gewährleistet, dass das verschobene Element korrekt in alphanumerischer Reihenfolge angelegt wird.

Mit der Eigenschaft Sorted können wir jedoch festlegen, dass die Einträge im TreeView-Steuerelement alphanumerisch sortiert werden. Damit diese Einstellung direkt zu Beginn angewendet wird, fügen wir die folgende Zeile zur Prozedur Form_Load hinzu:

objTreeView.Sorted = True

Schließlich müssen wir auch noch den Key des neuen übergeordneten Elements für den ausgeschnittenen und eingefügten Ordner-Datensatz in der Tabelle tblFolder definieren. Die beim Aufrufen des Kontextmenü-Befehls Einfügen ausgelöste Prozedur finden wir in Listing 4. Sie nimmt den Key des Zielelements als Parameter entgegen und prüft, ob es ein kopiertes Element in strKeyOrdnerAusgeschnitten gibt.

Public Function OrdnerEinfuegen(strKeyZiel As String)
     Dim objNodeAusgeschnittenOderKopiert As MSComctlLib.Node
     If Not Len(strKeyOrdnerAusgeschnitten) = 0 Then
         Set objNodeAusgeschnittenOderKopiert = objTreeview.Nodes(strKeyOrdnerAusgeschnitten)
         If Not objNodeAusgeschnittenOderKopiert Is Nothing Then
             If FS_OrdnerVerschieben(Mid(strKeyOrdnerAusgeschnitten, 2), Mid(strKeyZiel, 2)) = True Then
                 Call ParentInOrdnertabelleAendern(Mid(objNodeAusgeschnittenOderKopiert.Key, 2), Mid(strKeyZiel, 2))
                 Set objNodeAusgeschnittenOderKopiert.Parent = objTreeview.Nodes(strKeyZiel)
             Else
                 MsgBox "Ordner konnte im Dateisystem nicht verschoben werden.", vbOKOnly + vbCritical, "Fehler"
             End If
         End If
     Else
         ''... Kopierten Ordner einfügen
     End If
     objTreeview.Sorted = True
End Function

Listing 4: Prozedur zum Einfügen eines Ordners

Ist das der Fall, referenziert sie das entsprechende Element über den Key und prüft abermals, ob dieses Element vorhanden ist. Falls ja, ruft sie die weiter unten beschriebene Funktion FS_OrdnerVerschieben auf und übergibt dieser die IDs des zu verschiebenden Ordners und des Zielordners. FS_OrdnerVerschieben gibt den Wert True zurück, wenn das Verschieben im Dateisystem erfolgreich war.

In diesem Fall ruft OrdnerEinfuegen die Prozedur ParentInOrdnertabelleAendern auf und übergibt dieser die ID des ausgeschnittenen Elements und die des neuen Parent-Elements als Parameter.

Außerdem stellt sie die Eigenschaft Parent des verschobenen Elements auf das neue übergeordnete Element ein.

Die Prozedur ParentInOrdnertabelleAendern nimmt die ID des zu verschiebenden Elements sowie die ID des neuen Parent-Elements entgegen und ändert den Datensatz der Tabelle tblFolders für den betroffenen Datensatz, indem sie den Wert des Feldes ParentID auf die ID des neuen übergeordneten Elements einstellt:

Ende des frei verfügbaren Teil. Wenn Du mehr lesen möchtest, hole Dir ...

den kompletten Artikel im PDF-Format mit Beispieldatenbank

diesen und alle anderen Artikel mit dem Jahresabo

Schreibe einen Kommentar