Im Artikel „Ordner und Dateien in Access-Tabellen einlesen“ (www.access-im-unternehmen.de\/1583) haben wir gezeigt, wie wir schnell Ordner und Dateien in Tabellen speichern, in „Dateien schnell im TreeView-Steuerelement anzeigen“ (www.access-im-unternehmen.de\/1584) 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?<\/b><\/p>\n
Voraussetzung<\/h2>\n
Wir bauen in diesem Artikel auf dem Beispielformular frmDateienImTreeView<\/b> auf, das wir im Artikel Dateien schnell im TreeView-Steuerelement anzeigen<\/b> (www.access-im-unternehmen.de\/1584<\/b>) bereits vorgestellt haben (siehe Bild 1).<\/p>\n
![\"TreeView-Steuerelement](\"..\/fileadmin\/_temp_\/2026_02\/pic_1585_005.png\")
<\/p>\n
Bild 1: TreeView-Steuerelement mit den Einträgen, mit denen wir arbeiten wollen<\/span><\/b><\/p>\n Als Erstes wollen wir uns um die Anzeige eines Ordners oder einer Datei direkt im Windows Explorer kümmern und für diesen Zweck die benötigten Funktionen programmieren. 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<\/b>-Steuerelement.<\/p>\n Die Prozedur zum Anzeigen eines Ordners im Windows Explorer ist denkbar einfach. Wir müssen nur die Anwendung Explorer.exe <\/b>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 <\/b>nimmt den Pfad des anzuzeigenden Ordners als Parameter entgegen:<\/p>\n Sie ruft die VBA-Funktion Shell<\/b> 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:<\/p>\n Wir können noch einen Schritt weitergehen und direkt eine Datei im Windows Explorer markieren. Die entsprechende Prozedur nennen wir ShowFileInExplorer<\/b>:<\/p>\n Sie verwendet vor der Angabe des Pfades zu der zu markierenden Datei den Parameter \/select<\/b>. Diese Prozedur rufen wir beispielsweise für die aktuelle Datenbankdatei wie folgt auf:<\/p>\n Die Prozedur, mit der wir eine Datei direkt in der jeweiligen Anwendung öffnen können, heißt OpenFile<\/b> und verwendet die Methode FollowHyperlink <\/b>des Application<\/b>-Objekts:<\/p>\n Um zum Beispiel eine Bilddatei aus dem aktuellen Datenbankverzeichnis anzuzeigen, nutzen wir den folgenden Aufruf:<\/p>\n Für verschiedene Aktionen müssen wir zuvor das angeklickte Node<\/b>-Element referenzieren – zum Beispiel, wenn wir eine Aktion beim Doppelklick darauf ausführen wollen.<\/p>\n Also deklarieren wir im Kopf des Klassenmoduls eine Variable, um das aktuelle Element zu referenzieren:<\/p>\n Wenn der Benutzer auf ein Node<\/b>-Element klickt, soll dieses mit objCurrentNode <\/b>referenziert werden. Wenn der Benutzer auf einen freien Bereich im TreeView<\/b>-Steuerelement klickt, soll die Objektvariable objCurrentNode <\/b>geleert werden.<\/p>\n 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 <\/b>auswählen und im rechten Auswahlfeld MouseDown<\/b>. Die so angelegte Prozedur füllen wir mit den folgenden Anweisungen:<\/p>\n Die Prozedur erhält mit den Parametern X <\/b>und Y <\/b>die beim Klicken mit der Maus gültigen Koordinaten des Mauszeigers. Diese werten wir mit der Eigenschaft HitTest <\/b>aus.<\/p>\n Wenn der Benutzer ein Node<\/b>-Element angeklickt hat, wird ein Verweis darauf zurückgeliefert. Wenn nicht, ist nicht nur objCurrentNode<\/b> leer, sondern wir wollen dann auch den aktuell markierten Eintrag abwählen. Dazu stellen wir die Eigenschaft SelectedItem <\/b>auf Nothing <\/b>ein.<\/p>\n Wenn wir die Funktion OpenFile<\/b> per Doppelklick auf einen der Datei-Einträge im TreeView<\/b>-Steuerelement aufrufen wollen, benötigen wir das Ereignis DblClick<\/b>. Dieses liefert keinerlei Parameter, die Informationen über das angeklickte Node<\/b>-Element enthalten.<\/p>\n 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<\/b>-Element über die Objektvariable objCurrentNode<\/b>. Wenn der Benutzer einen Doppelklick außerhalb der Node<\/b>-Elemente durchgeführt hat, ist objCurrentNode <\/b>leer.<\/p>\n Diese Variable werten wir in der folgenden Ereignisprozedur aus. Nur wenn objCurrentNode <\/b>nicht Nothing <\/b>ist, ermitteln wir den Key aus der Key<\/b>-Eigenschaft und lesen danach mit Left <\/b>das erste Zeichen aus, das entweder f <\/b>(Folder<\/b>) oder i <\/b>(File<\/b>) lautet.<\/p>\n 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.<\/p>\n Wir haben in den Tabellen tblFolders <\/b>und tblFiles <\/b>nur die Namen des jeweiligen Ordners oder der Datei gespeichert, nicht den vollständigen Pfad zum entsprechenden Element.<\/p>\n Deshalb müssen wir, um die doppelt angeklickte Datei zu öffnen, erst den Pfad ermitteln. Dazu nutzen wir die Funktion GetFilePath<\/b>, der wir die ID der Datei aus dem Key übergeben. Nachdem wir damit den Pfad ermittelt haben, können wir die Funktion OpenFile <\/b>aufrufen und mit dieser die Datei mit dem entsprechenden Pfad öffnen:<\/p>\n Die Funktion GetFilePath <\/b>erwartet die ID der Datei aus der Tabelle tblFiles<\/b> (siehe Listing 1).<\/p>\n Listing 1: Die Funktion GetFilePath holt den Pfad zu dem Ordner oder der Datei mit der angegebenen ID.<\/span><\/b><\/p>\n Sie liest zunächst die ID des übergeordneten Ordners aus dem Feld ParentID <\/b>der Tabelle tblFiles <\/b>aus.<\/p>\n Dann trägt sie in die Variable strPath <\/b>zunächst nur den Dateinamen dieser Datei ein.<\/p>\n In der folgenden Do While<\/b>-Schleife, die so lange durchlaufen wird, bis es keinen übergeordneten Ordner mehr gibt (lngFolder = 0<\/b>) liest die Prozedur zunächst den Namen des übergeordneten Ordners aus der Tabelle tblFolders <\/b>in die Variable strFolder <\/b>ein.<\/p>\n Dann fügt sie diesen Namen, getrennt durch einen Backslash, vorn an den Inhalt der Variablen strPath <\/b>an und speichert das Ergebnis wieder in strPath<\/b>.<\/p>\n Außerdem ermittelt sie nun die ID des übergeordneten Elements für diesen Ordner aus der Tabelle tblFolders<\/b> und schreibt diese in lngFolderID<\/b>.<\/p>\n Auf diese Weise entsteht ein Pfad wie Dir03\\Dir0303\\Test030303.txt<\/b>. Da wir die Ordner und Dateien immer von dem im Feld Basisordner <\/b>der Tabelle tblOptionen <\/b>aus in den Tabellen tblFolders <\/b>und tblFiles <\/b>speichern, müssen wir nun nur noch den dort gespeicherten Pfad hinzufügen, um den vollständigen Pfad zu erhalten.<\/p>\n Diesen gibt die Funktion als Ergebnis zurück.<\/p>\n 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.<\/p>\n 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:<\/p>\n Beim Klick auf eine Datei sind diese Befehle vorgesehen:<\/p>\n Und beim Klick auf den leeren Raum außerhalb der Node<\/b>-Elemente bieten wir diese Befehle an:<\/p>\n Kontextmenüs legen wir auf dem herkömmlichen Wege über die CommandBars<\/b>-Auflistung an. Um diese anzuzeigen, verwenden wir die MouseDown<\/b>-Eigenschaft des TreeView<\/b>-Steuerelements. Dazu erweitern wir die bereits vorhandene Ereignisprozedur wie in Listing 2.<\/p>\n Listing 2: Prozedur zum Aufruf der verschiedenen Kontextmenüs<\/span><\/b><\/p>\n Das Ergebnis soll beispielsweise für Ordner-Elemente wie in Bild 2 aussehen.<\/p>\n Bild 2: Anzeigen des Kontextmenüs für einen Ordner<\/span><\/b><\/p>\n Wir ermitteln hier nach wie vor das aktuell markierte Node<\/b>-Element. Dann prüfen wir, ob der Benutzer die rechte Maustaste betätigt hat (acRightButton<\/b>). Ist das der Fall, prüfen wir, ob aktuell ein Node<\/b>-Element markiert ist.<\/p>\n Falls ja, lesen wir aus der Key<\/b>-Eigenschaft das erste Zeichen aus. Im Falle von f <\/b>(Folder<\/b>) rufen wir die Prozedur CreateCommandBarFolder <\/b>auf. Lautet der Buchstabe i <\/b>(File<\/b>), rufen wir CreateCommandBarFile <\/b>auf. Falls gerade kein Node<\/b>-Element markiert ist, rufen wir die Prozedur CreateCommandBarOther <\/b>auf.<\/p>\n Die Prozedur CreateCommandBarFolder <\/b>soll das Kontextmenü für einen Ordner anzeigen (siehe Listing 3).<\/p>\n Listing 3: Prozedur zum Anzeigen des Kontextmenüs für Ordner<\/span><\/b><\/p>\n Sie nimmt den Verweis auf das Node<\/b>-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.<\/p>\n Falls das Kontextmenü bereits vorhanden ist, löschen wir es bei deaktivierter Fehlerbehandlung zunächst mit der Delete<\/b>-Methode.<\/p>\n Danach legen wir ein neues Kontextmenü namens Ordner <\/b>an und legen den Typ auf msoBarPopup <\/b>fest. Außerdem stellen wir den Parameter Temporary <\/b>auf True <\/b>ein, damit es beim Beenden der Access-Session anschließend wieder gelöscht wird<\/p>\n 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<\/b>-Anweisung direkt mit dem neu erstellten Element und weisen damit die drei Eigenschaften zu:<\/p>\n Für die Eigenschaft OnAction <\/b>legen wir jeweils eine Zeichenkette fest, die den Funktionsnamen enthält sowie den Key des aktuell markierten Node<\/b>-Elements aus der Variablen strKey<\/b>, zum Beispiel:<\/p>\n Schließlich zeigen wir das Kontextmenü mit der Methode ShowPopup <\/b>an.<\/p>\n Das waren die einfachen Aufgaben. Nun folgen die einzelnen Funktionen, die beim Anklicken der Kontextmenü-Einträge ausgelöst werden sollen.<\/p>\n Diese legen wir im Standardmodul mdlKontextmenues<\/b> nach dem folgenden Schema an – hier für das Kopieren eines Ordners:<\/p>\n Wie wir diese Funktionen füllen, sehen wir in den folgenden Abschnitten.<\/p>\n Was genau soll beim Ausschneiden, Kopieren und Einfügen von Ordnern geschehen? Wir wollen zunächst auf der Ebene des TreeView<\/b>-Steuerelements arbeiten. Das Nachziehen der Vorgänge im Dateisystem fügen wir später hinzu.<\/p>\n 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.<\/p>\n 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 <\/b>des Elements in dieser Variablen.<\/p>\n 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 <\/b>und strKeyOrdnerKopiert <\/b>anlegen.<\/p>\n Dann müssten wir, wenn wir einen Ordner kopieren, den Key in die Variable strKeyOrdnerKopiert<\/b> schreiben und die Variable strKeyOrdnerAusgeschnitten <\/b>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.<\/p>\n Alternativ könnten wir einfach eine Variable namens strKeyAusgeschnittenOderKopiert<\/b> anlegen und eine weitere Boolean<\/b>-Variable, die angibt, ob ein Ordner ausgeschnitten oder kopiert werden soll. Wir entscheiden uns für die erste Variante:<\/p>\n Folglich hinterlegen wir für die beiden Kontextmenü-Funktionen die folgenden Anweisungen:<\/p>\n Wenn wir mit der nächsten Funktion den Einfügevorgang durchführen wollen, benötigen wir Zugriff auf die TreeView<\/b>-Objektvariable. Diese ziehen wir daher vom Klassenmodul in das Modul mdlGlobal<\/b> und stellen die Sichtbarkeit auf Public <\/b>ein:<\/p>\n 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.<\/p>\n An dieser Stelle könnte man annehmen, dass wir uns das Anzeigen der Elemente im TreeView<\/b>-Steuerelement durch Setzen der Eigenschaft Sorted <\/b>auf den Wert True <\/b>erleichtern könnten.<\/p>\n Das ist jedoch nicht der Fall, denn wir haben noch eine weitere Sortierungsebene: Es sollen zuerst die Verzeichnisse in aufsteigender Reihenfolge angezeigt werden und erst dann die Dateien, ebenfalls aufsteigend sortiert.<\/p>\n Wir müssen uns also selbst um die korrekte Reihenfolge kümmern. Beim erstmaligen Anzeigen ist das noch einfach, denn wir fügen die Elemente einfach in der entsprechenden Sortierung hinzu.<\/p>\n Beim späteren Ausschneiden oder Kopieren und Einfügen müssen wir uns allerdings mit einem selbst gebauten Mechanismus behelfen, um neu eingefügte Elemente an der richtigen Stelle einzufügen.<\/p>\n 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 <\/b>definieren.<\/p>\n Die beim Aufrufen des Kontextmenü-Befehls Einfügen<\/b> 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 <\/b>gibt.<\/p>\nOrdner oder Dateien direkt im Windows Explorer anzeigen<\/h2>\n
Ordner direkt im Windows Explorer anzeigen<\/h2>\n
Public Sub <\/span>OpenFolderInExplorer(strPath As String<\/span>)\r\n Shell \"explorer.exe \"\"\" & strPath & \"\"\"\", _\r\n vbNormalFocus\r\nEnd Sub<\/span><\/pre>\nCall<\/span> OpenFolderInExplorer(CurrentProject.Path)<\/pre>\nDatei direkt im Windows Explorer anzeigen<\/h2>\n
Public Sub <\/span>ShowFileInExplorer(strPath As String<\/span>)\r\n Shell \"explorer.exe \/select,\"\"\" & strPath & \"\"\"\", _\r\n vbNormalFocus\r\nEnd Sub<\/span><\/pre>\nCall<\/span> ShowFileInExplorer(CurrentDb.name)<\/pre>\nDatei mit der jeweiligen Anwendung öffnen<\/h2>\n
Public Sub <\/span>OpenFile(strPath As String<\/span>)\r\n Application.FollowHyperlink strPath\r\nEnd Sub<\/span><\/pre>\nCall<\/span> OpenFile(CurrentProject.Path & \"\\pic005.png\")<\/pre>\nAngeklicktes Node-Element ermitteln<\/h2>\n
Dim <\/span>objCurrentNode As <\/span>MSComctlLib.Node<\/pre>\nPrivate Sub <\/span>ctlTreeView_MouseDown( _\r\n ByVal Button As Integer<\/span>, ByVal Shift As Integer<\/span>, _\r\n ByVal x As Long<\/span>, ByVal y As Long<\/span>)\r\n Set<\/span> objCurrentNode = ctlTreeView.Object.HitTest(x, y)\r\n If <\/span>objCurrentNode Is Nothing Then<\/span>\r\n Me.ctlTreeView.Object.SelectedItem = Nothing\r\n End If<\/span>\r\nEnd Sub<\/span><\/pre>\nAktuell markierte Datei per Doppelklick öffnen<\/h2>\n
Private Sub <\/span>ctlTreeView_DblClick()\r\n Dim <\/span>strPath As String<\/span>\r\n Dim <\/span>strKey As String<\/span>\r\n \r\n If <\/span>Not<\/span> objCurrentNode Is Nothing Then<\/span>\r\n strKey = objCurrentNode.Key\r\n Select Case Left<\/span>(strKey, 1)\r\n Case <\/span>\"i\"\r\n strPath = GetFilePath(Mid<\/span>(strKey, 2))\r\n Call<\/span> OpenFile(strPath)\r\n End Select<\/span>\r\n End If<\/span>\r\nEnd Sub<\/span><\/pre>\nPfad zu einer Datei ermitteln<\/h2>\n
Public Function <\/span>GetFilePath(ByVal lngFileID As Long<\/span>) As String<\/span>\r\n Dim <\/span>lngFolderID As Long<\/span>\r\n Dim <\/span>strPath As String<\/span>\r\n Dim <\/span>strFolder As String<\/span>\r\n lngFolderID = Nz(DLookup(\"ParentID\", \"tblFiles\", \"FileID = \" & lngFileID), 0)\r\n strPath = Nz(DLookup(\"Filename\", \"tblFiles\", \"FileID = \" & lngFileID), 0)\r\n Do While<\/span> Not<\/span> lngFolderID = 0\r\n strFolder = Nz(DLookup(\"Foldername\", \"tblFolders\", \"FolderID = \" & lngFolderID), 0)\r\n strPath = strFolder & \"\\\" & strPath\r\n lngFolderID = Nz(DLookup(\"ParentID\", \"tblFolders\", \"FolderID = \" & lngFolderID), 0)\r\n Loop<\/span>\r\n \r\n strPath = DLookup(\"Basispfad\", \"tblOptionen\") & \"\\\" & strPath\r\n GetFilePath = strPath\r\nEnd Function<\/span><\/pre>\nKontextmenü im TreeView-Steuerelement anzeigen<\/h2>\n
\n
\n
\n
Kontextmenüs anlegen<\/h2>\n
Private Sub <\/span>ctlTreeView_MouseDown(ByVal Button As Integer<\/span>, ByVal Shift As Integer<\/span>, ByVal x As Long<\/span>, ByVal y As Long<\/span>)\r\n Dim <\/span>strTyp As String<\/span>\r\n \r\n Set<\/span> objCurrentNode = ctlTreeView.Object.HitTest(x, y)\r\n \r\n If <\/span>objCurrentNode Is Nothing Then<\/span>\r\n Me.ctlTreeView.Object.SelectedItem = Nothing\r\n End If<\/span>\r\n Select Case Button\r\n Case <\/span>acRightButton\r\n If <\/span>Not<\/span> objCurrentNode Is Nothing Then<\/span>\r\n strTyp = Left<\/span>(objCurrentNode.Key, 1)\r\n Select Case strTyp\r\n Case <\/span>\"f\"\r\n Call<\/span> CreateCommandBarFolder()\r\n Case <\/span>\"i\"\r\n Call<\/span> CreateCommandBarFile()\r\n End Select<\/span>\r\n Else<\/span>\r\n Call<\/span> CreateCommandBarOther\r\n End If<\/span>\r\n End Select<\/span>\r\nEnd Sub<\/span><\/pre>\n![\"Anzeigen](\"..\/fileadmin\/_temp_\/2026_02\/pic_1585_006.png\")
<\/p>\nKontextmenü für Ordner anzeigen<\/h2>\n
Private Sub <\/span>CreateCommandBarFolder()\r\n Dim <\/span>strKey As String<\/span>\r\n Dim <\/span>cbr As <\/span>Office.CommandBar\r\n strKey = objCurrentNode.Key\r\n On Error Resume Next<\/span>\r\n CommandBars(\"Ordner\").Delete\r\n On Error GoTo<\/span> 0\r\n Set<\/span> cbr = CommandBars.Add(\"Ordner\", msoBarPopup, False, True<\/span>)\r\n With<\/span> cbr.Controls.Add(msoControlButton)\r\n .Caption = \"Ordner kopieren\"\r\n .OnAction = \"=OrdnerKopieren(''\" & strKey & \"'')\"\r\n .FaceId = 1667\r\n End With<\/span>\r\n With<\/span> cbr.Controls.Add(msoControlButton)\r\n .Caption = \"Ordner ausschneiden\"\r\n .OnAction = \"=OrdnerAusschneiden(''\" & strKey & \"'')\"\r\n .FaceId = 1669\r\n End With<\/span>\r\n With<\/span> cbr.Controls.Add(msoControlButton)\r\n .Caption = \"Ordner einfügen\"\r\n .OnAction = \"=OrdnerEinfuegen(''\" & strKey & \"'')\"\r\n .FaceId = 22\r\n End With<\/span>\r\n With<\/span> cbr.Controls.Add(msoControlButton)\r\n .Caption = \"Ordner löschen\"\r\n .OnAction = \"=OrdnerLoeschen(''\" & strKey & \"'')\"\r\n .FaceId = 2500\r\n End With<\/span>\r\n With<\/span> cbr.Controls.Add(msoControlButton)\r\n .Caption = \"Neuer Ordner\"\r\n .OnAction = \"=NeuerOrdner(''\" & strKey & \"'')\"\r\n .FaceId = 1755 ''4088 ''4274 ''2031 ''\r\n End With<\/span>\r\n With<\/span> cbr.Controls.Add(msoControlButton)\r\n .Caption = \"Ordner im Windows Explorer anzeigen\"\r\n .OnAction = \"=OrdnerExplorer(''\" & strKey & \"'')\"\r\n .FaceId = 32\r\n End With<\/span>\r\n With<\/span> cbr.Controls.Add(msoControlButton)\r\n .Caption = \"Pfad des Ordners kopieren\"\r\n .OnAction = \"=OrdnerPfadKopieren(''\" & strKey & \"'')\"\r\n .FaceId = 19\r\n End With<\/span> \r\n With<\/span> cbr.Controls.Add(msoControlButton)\r\n .Caption = \"Ordner umbenennen\"\r\n .OnAction = \"=OrdnerUmbenennen(''\" & strKey & \"'')\"\r\n .FaceId = 2512\r\n End With<\/span>\r\n cbr.ShowPopup\r\nEnd Sub<\/span><\/pre>\n\n
.OnAction = \"=OrdnerKopieren(''\" & strKey & \"'')\"<\/pre>\nFunktionen für das Ordner-Kontextmenü<\/h2>\n
Public Function <\/span>OrdnerKopieren(strKey As String<\/span>)\r\n MsgBox<\/span> \"Ordner kopieren\"\r\nEnd Function<\/span><\/pre>\nOrdner und Datei ausschneiden, kopieren und einfügen<\/h2>\n
Public <\/span>strKeyOrdnerAusgeschnitten As String<\/span>\r\nPublic <\/span>strKeyOrdnerKopiert As String<\/span><\/pre>\nPublic Function <\/span>OrdnerKopieren(strKey As String<\/span>)\r\n strKeyOrdnerKopiert = strKey\r\n strKeyOrdnerAusgeschnitten = \"\"\r\nEnd Function<\/span>\r\n \r\nPublic Function <\/span>OrdnerAusschneiden(strKey As String<\/span>)\r\n strKeyOrdnerKopiert = \"\"\r\n strKeyOrdnerAusgeschnitten = strKey\r\nEnd Function<\/span><\/pre>\nEinfügen eines ausgeschnittenen Ordners<\/h2>\n
Public <\/span>objTreeview As <\/span>MSComctlLib.TreeView<\/pre>\nPublic Function <\/span>OrdnerEinfuegen(strKeyZiel As String<\/span>)\r\n Dim <\/span>objNodeAusgeschnittenOderKopiert As <\/span>MSComctlLib.Node\r\n If <\/span>Not<\/span> Len<\/span>(strKeyOrdnerAusgeschnitten) = 0 Then<\/span>\r\n Set<\/span> objNodeAusgeschnittenOderKopiert = objTreeview.Nodes(strKeyOrdnerAusgeschnitten)\r\n If <\/span>Not<\/span> objNodeAusgeschnittenOderKopiert Is Nothing Then<\/span>\r\n If <\/span>FS_OrdnerVerschieben(Mid<\/span>(strKeyOrdnerAusgeschnitten, 2), Mid<\/span>(strKeyZiel, 2)) = True<\/span> Then<\/span>\r\n Call<\/span> ParentInOrdnertabelleAendern(