Treeview erstellen anhand von gespeicherten Pfaden

partywelt · Hält's aus hier Beiträge: 3

Hallo zusammen, ich habe ein Problem. Ich bin dabei ein Backup Programm zu programmieren. Ich erstelle einen Auftrag, den ich in einer XML Datei speichere. Den Auftrag erstelle ich mit TreeViews, in der ich eine Art Windows Explorer erstelle - Dies funktioniert auch ohne Probleme.

Mein Problem ist nun wenn ich diesen Auftrag bearbeiten will und ich mehrere Quellen angegeben habe. Übergebe die Quellen in einem String z.B "D:\\Eigene Bilder\Urlaub|D:\\Eigene Bilder\Familie".

Dann lasse ich mir meinen TreeView aufbauen. Mit einer Quelle funktioniert das wunderbar. Sobald ich aber mehrere Quellen habe baut er mir den Node Eigene Bilder 2 mal auf (oder mehrmals, je nach dem wie oft der Ordner vorkommt)

Beispiel:
C:\
D:\
Eigene Dokumente\
Eigene Musik\
Eigene Bilder\
Fotos\
Arbeit\
Urlaub\ (wird gecheckt)
Familie\
Fotos\
Arbeit\
Urlaub\
Familie\ (wird gecheckt)
...

Habe schon versucht abzufragen ob der Node schon existiert, trotzdem krieg ich es nicht hin.

Hier ist mein Code, vielleicht habt ihr eine ganz andere Idee wie ich den TreeView aufbauen kann:

markieren

C#-Quelltext

1:
2:
3:
4:
5:
6:
7:
8:
9:
10:
11:
12:
13:
14:
15:
16:
17:
18:
19:
20:
21:
22:
23:
24:
25:
26:
27:
28:
29:
30:
31:
32:
33:
34:
35:
36:
37:
38:
39:
40:
41:
42:
43:
44:
45:
46:
47:
48:
49:
50:
51:
52:
53:
54:
55:
56:
57:
58:
59:
60:
61:
62:
63:
64:
65:
66:
67:
68:
69:
70:
71:
72:
73:
74:
75:
76:
77:
78:
79:
80:
81:
82:
83:
84:
85:
86:
87:
88:
89:
90:
91:
92:
93:
94:
95:
96:
97:
98:
99:
100:
101:
102:
103:
104:
105:
106:
107:
108:
109:
110:
111:
112:
113:
114:
115:
116:
117:
118:
119:
120:
121:
122:
123:
124:
125:
126:
127:
128:
129:
130:
131:
132:
133:
134:
135:
136:
137:
138:
139:
140:
141:
142:
143:
144:
145:
146:
147:
148:
149:
150:
151:
152:
153:
154:

public Form3(werte)
{
    drives_Src(source); (ruft Funktion zum Aufbau des TreeViews auf)
}

private void drives_Src(String source)
        {
            TreeNode node = new TreeNode();
            foreach (string drive in Directory.GetLogicalDrives())
            {
                try
                {
                    node = treeView1.Nodes.Add(drive);

//prüfen ob auf einer Festplatte mehrere Quellen vorhanden sind
                    string NodeSrc = "";
                    Boolean fehler = true;
                    string NodeSource = "";
                    string[] sources = source.Split('|');
                    foreach (string strSource in sources)
                    {
                        string[] strNode = strSource.Split('\\');
                        string NodeSrctemp = strNode[0] + "\\";
                        if (drive == NodeSrctemp)
                        {
                            if (NodeSrctemp == NodeSrc)
                            {
                                NodeSource = NodeSource + "|" + strSource;
                                fehler = false;
                            }
                            else
                            {
                                NodeSrc = NodeSrctemp;
                                NodeSource = strSource;
                                fehler = false;
                            }
                        }
                    }
                    if (fehler == false)
                    {
                        eNode_Src(node.FullPath, node, NodeSource, true);
                        node.Expand();
                    }
                    else
                    {
                        //Dummynodes einfügen
                        TreeNode dummy = new TreeNode();
                        dummy = node.Nodes.Add("");
                        dummy.ImageKey = "folder";
                    }
                }
                catch { }
            }
        } //Ende drives_Src()

// Bestehende Quellen anzeigen
        private void eNode_Src(String Src, TreeNode node, String arrSrc, Boolean fehler)
        {
            try
            {
                //node.Nodes.Clear();
                foreach (string dir in Directory.GetDirectories(Src)) // Ordner in TreeView einfügen
                {
                    try
                    {     
                        TreeNode dir_t = new TreeNode();
                        string[] ordnername = dir.Split('\\');
                        int i = ordnername.Length - 1;
                        dir_t = node.Nodes.Add(ordnername[i].ToString());

                        CallRecursive(treeView1); // gibt alle vorhanden Nodes der TreeView im Array openNodes aus --> siehe foreach (TreeNode element in openNodes)

                        string[] sources = arrSrc.Split('|'); // Splittet den String in dem die Quellen stehen
                        foreach (string SrcLong in sources)
                        {
                            Boolean vorhanden = false;
                            foreach (TreeNode element in openNodes)
                            {
                                if (SrcLong == element.FullPath && element.FullPath == dir_t.FullPath)
                                {
                                    MessageBox.Show(SrcLong);
                                    fehler = false;
                                    dir_t.Checked = true;
                                    vorhanden = true;

                                    //Dummynodes einfügen
                                    TreeNode dummy = new TreeNode();
                                    dummy = dir_t.Nodes.Add("");
                                    dummy.ImageKey = "folder";
                                }
                            }
                            if (vorhanden == false)
                            {
                                if (dir_t.FullPath == SrcLong)
                                {
                                    fehler = false;
                                    dir_t.Checked = true;

                                    //Dummynodes einfügen
                                    TreeNode dummy = new TreeNode();
                                    dummy = dir_t.Nodes.Add("");
                                    dummy.ImageKey = "folder";
                                }
                                else
                                {
                                    if (SrcLong.Contains(dir_t.FullPath))
                                    {
                                        string strdir = dir + "\\";
                                        eNode_Src(strdir, dir_t, SrcLong, fehler);
                                        dir_t.Expand();
                                        fehler = false;
                                    }
                                    else
                                    {
                                        //Dummynodes einfügen
                                        TreeNode dummy = new TreeNode();
                                        dummy = dir_t.Nodes.Add("");
                                        dummy.ImageKey = "folder";
                                    }
                                }
                            }
                        }                   
                    }//Ende try
                    catch 
                    {
                    
                    }
                }
                foreach (string file in Directory.GetFiles(Src)) //Dateien in TreeView einfügen
                {
                    try
                    {
                        
                        TreeNode file_t = new TreeNode();
                        string[] filename = file.Split('\\');
                        int i = filename.Length - 1;
                        file_t = node.Nodes.Add(file.ToString(), filename[i].ToString());

                        string[] sources = arrSrc.Split('|');
                        foreach (string SrcLong in sources)
                        {
                            if (file_t.FullPath == SrcLong)
                            {
                                fehler = false;
                                this.treeView1.SelectedNode = file_t;
                                this.treeView1.SelectedNode.Checked = true;
                            }
                        }
                    }
                    catch { }
                }
            }
            catch { }
        }

partywelt · Hält's aus hier Beiträge: 3

Also ich habe aus einem anderem Forum einen Hinweis bekommen

Hier der Code

markieren

C#-Quelltext

1:
2:
3:
4:
5:
6:
7:
8:
9:
10:
11:
12:
13:
14:
15:
16:
17:
18:
19:
20:
21:
22:
23:
24:
25:
26:
27:
28:
29:
30:
31:
32:
33:
34:
35:
36:
37:
38:
39:
40:
41:
42:
43:
44:
45:
46:
47:
48:
49:
50:
51:
52:
53:
54:
55:
56:
57:

        private void test(TreeNode parentNode, String NodeSource)
        {
            //Hashtable erzeugen
            Hashtable dictNode = new Hashtable();

            //Hier liegen die String in Form "D:\Eigene Bilder\Urlaub|D:\Musik\Internet|D:\Musik\Alben" per | getreent
            string[] sources = NodeSource.Split('|');
            foreach (string readDir in sources)
            {
                //Ausgelesene Zeile bei "\" splitten:
                string[] splittedPath = readDir.Split('\\');

                string strBegin = "";

                parentNode = null;

                foreach (string pathSplitter in splittedPath)
                {
                    //Wenn das Element leer ist, abbrechen
                    if (pathSplitter == "")
                    {
                        break;
                    }

                    //strBegin += "\\" + pathSplitter;
                    strBegin += pathSplitter+ "\\";

                    if (dictNode.ContainsKey(strBegin))
                    {
                        parentNode = (TreeNode)dictNode[strBegin];
                        continue;
                    }

                    dictNode[strBegin] = new TreeNode(pathSplitter);

                    if (parentNode == null)
                    {
                        this.treeView1.Nodes.Add((TreeNode)dictNode[strBegin]);
                    }
                    else
                    {
                        //MessageBox.Show(parentNode.FullPath);

                        parentNode.Nodes.Add((TreeNode)dictNode[strBegin]);
                        parentNode.Expand();

                        //Ausgewählten Node checken
                        if (((TreeNode)dictNode[strBegin]).FullPath == readDir)
                        {
                            ((TreeNode)dictNode[strBegin]).Checked = true;
                        }

                    }
                    parentNode = (TreeNode)dictNode[strBegin];
                }
            }
        }

Mein Problem ist nun, dass er mir nun die Ausgewählten Quellen ordentlich anzeigt. Nur ich möchte, dass bei einem Pfad "D:\Eigene Musik\Alben" Mir alle Verzeichnisse und Dateien in den Ordnern D:\ und D:\Eigene Musik angezeigt werden und entsprechend D:\Eigene Musik\Alben" gecheckt werden. Ebenso soll "D:\Eigene Musik\Internet" gecheckt werden.

Hab es schon über ein GetDirectory parentNode probiert, aber dann erstellt der mir den Inhalt von D:\Eigene Musik 2mal (Wenn ich mehr Ordner in D:\Eigene Musik" checken würde würde er mir die auch mehrmals checken.

Habt ihr eine Idee wie ich das lösen kann mir GetDirectory und GetFiles und prüfen kann ob der Node schon vorhanden, sodass mir eine komplette Ordnerdtruktur bis zum gespeichertem Pfad angezeigt wird, aber jedoch nur einfach und die gewählten Pfade gecheckt werden???

Wäre euch echt Dankbar, bin am verzweifeln

Gruß partywelt

partywelt · Hält's aus hier Beiträge: 3

Habe es über Umwege und Zwischenvariablen geschafft mein Ziel zu erreichen

Zitat:

using System;
using System.Collections.Generic;
using System.ComponentModel;
using System.Data;
using System.Drawing;
using System.Drawing.Imaging;
using System.Linq;
using System.Text;
using System.Windows.Forms;
using System.IO;
using System.Security;
using System.Security.Permissions;
using System.Security.Policy;
using System.Runtime.InteropServices;
using System.Collections;
using System.Data.SqlClient;
using System.Xml;

namespace WindowsFormsApplication1
{
public partial class Form4 : Form
{
Hashtable treenodes = new Hashtable();
ArrayList openNodes = new ArrayList();
public Form4(string Src)
{
InitializeComponent();
drives_Src(Src);
checkNodes(Src);
}

private void drives_Src(string source)
{
TreeNode node = new TreeNode();

foreach (string drive in Directory.GetLogicalDrives())
{
try
{
string NodeSrc = "";
Boolean fehler = true;
string NodeSource = "";
string[] sources = source.Split('|');
foreach (string strSource in sources)
{
string[] strNode = strSource.Split('\\');
string NodeSrctemp = strNode[0] + "\\";
if (drive == NodeSrctemp)
{
if (NodeSrctemp == NodeSrc)
{
NodeSource = NodeSource + "|" + strSource;
fehler = false;
}
else
{
NodeSrc = NodeSrctemp;
NodeSource = strSource;
fehler = false;
}
}
}
if (fehler == false)
{
eNode_Src(NodeSource,drive);
}
else
{
DriveType drive_type = GetDriveType(drive);
string[] strdrive = drive.Split('\\');
node = treeView1.Nodes.Add(drive);

switch (drive_type.ToString())
{
case "DRIVE_FIXED":
node.ImageKey = "drive";
node.SelectedImageKey = "drive";
break;
case "DRIVE_REMOTE":
node.ImageKey = "network";
node.SelectedImageKey = "network";
break;
case "DRIVE_CDROM":
node.ImageKey = "cdrom";
node.SelectedImageKey = "cdrom";
break;
default:
node.ImageKey = "drive";
node.SelectedImageKey = "drive";
break;
}

//Dummynodes einfügen
TreeNode dummy = new TreeNode();
dummy = node.Nodes.Add("");
dummy.ImageKey = "folder";
}
}
catch { }
}
} //Ende drives_Src()

public enum DriveType
{
DRIVE_UNKNOWN = 0,
DRIVE_NO_ROOT_DIR = 1,
DRIVE_REMOVABLE = 2,
DRIVE_FIXED = 3,
DRIVE_REMOTE = 4,
DRIVE_CDROM = 5,
DRIVE_RAMDISK = 6
} //Ende DriveType

// Um heraus zu finden um was für ne laufwerksart es sich handelt...
[DllImport("KERNEL32", EntryPoint = "GetDriveType")]
public static extern DriveType GetDriveType(string sDrive);

int i = 0;

// TreeView Quelle
private void eNode_Src(string SrcNodes, string drive)
{
TreeNode parentNode = null;

string[] Sources = SrcNodes.Split('|');
foreach (string Source in Sources)
{
TreeNode tmp = null;
string SrcPart = "";
string[] splittetSrc = Source.Split('\\');
foreach (string SrcParted in splittetSrc)
{

if (SrcPart == "")
{
SrcPart = SrcParted + "\\";
Boolean vorhanden = false;

foreach (DictionaryEntry node in treenodes)
{
if (node.Value.ToString() == SrcPart)
{
vorhanden = true;
parentNode = (TreeNode)node.Key;
}
}

if (vorhanden != true)
{
parentNode = treeView1.Nodes.Add(drive);
parentNode.Expand();
treenodes.Add(parentNode, drive);
}
}
else
{
SrcPart += SrcParted + "\\";
parentNode = tmp;
}
foreach (string dir in Directory.GetDirectories(SrcPart))
{
try
{
Boolean vorhanden = false;
TreeNode dir_t = new TreeNode();
TreeNode test = new TreeNode();
string[] ordnername = dir.Split('\\');
i = ordnername.Length - 1;

foreach (DictionaryEntry node in treenodes)
{
if (node.Value.ToString() == dir)
{
vorhanden = true;
if (Source.Contains(dir) && dir != Source)
{
parentNode.Nodes.Remove((TreeNode)node.Key);
dir_t = parentNode.Nodes.Add(ordnername[i].ToString());
this.treeView1.Sort();
dir_t.Expand();
dir_t.ImageKey = "folder";
dir_t.SelectedImageKey = "folder";
tmp = dir_t;
}
}
}
if (vorhanden != true)
{
dir_t = parentNode.Nodes.Add(ordnername[i].ToString());
dir_t.Expand();
dir_t.ImageKey = "folder";
dir_t.SelectedImageKey = "folder";
if (Source.Contains(dir))
{
tmp = dir_t;
}
treenodes.Add(dir_t, dir);
}
}
catch (Exception ex)
{
MessageBox.Show("Catch: " + ex.Message + " dir: " + dir);
}
}
}
}
}//Ende treeView1 (Quelle)

private void checkNodes(String SrcNodes)
{
string[] tmpSources = SrcNodes.Split('|');
foreach (string Source in tmpSources)
{
//String Source vorbereiten
string strTemp = "";
string[] strSource = Source.Split('\\');

foreach (string tmpStr in strSource)
{
if (strTemp == "")
{
strTemp = tmpStr + "\\";
}
else
{
strTemp += "\\" + tmpStr;
}
}

// Hier werden die Nodes gecheckt
CallRecursive(treeView1, strTemp);
}
}

private void PrintRecursive(TreeNode treeNode, String Source)
{

if (treeNode.Text != "")
{
if (treeNode.FullPath == Source)
{
treeNode.Checked = true;
}
}

foreach (TreeNode tn in treeNode.Nodes)
{
PrintRecursive(tn, Source);
}
}

// Call the procedure using the TreeView.
private void CallRecursive(TreeView treeView, string Source)
{
TreeNodeCollection nodes = treeView.Nodes;
foreach (TreeNode n in nodes)
{
PrintRecursive(n, Source);
}
}
}
}

	Mitgliederliste
	Gruppen
	Das Team
	Richtlinien
	Synonyme