lantool

MainForm.cs (66309B)

---

 using System;
 using System.Collections;
 using System.Collections.Generic;
 using System.Diagnostics;
 using System.Drawing;
 using System.IO;
 using System.Text.RegularExpressions;
 using System.Windows.Forms;
 using LanTool.Classes;
 
 namespace LanTool
 {
 	public partial class MainForm : Form
 	{
 		#region Konstanten
 
 		internal const string DefaultHeader = "LanTool 1.6 - LumpLan #1 Edition";
 
 		#endregion
 
 		#region Felder
 
 		internal StuffItemTree m_MyDisks = new StuffItemTree("Meine Platten", false);
 
 		internal StuffItemTree m_OtherDisks = new StuffItemTree("Fremde Platten", true);
 
 		// Zähler für die Anzahl der Kopierthreads
 		int copyThreadCount = 0;
 
 		// Zähler für das Maximum des Fortschrittsbalkens
 		float maxProgressMB = 0;
 		float currentProgressMB = 0;
 
 		/// <summary>
 		/// Pfad für Config/Exclude-Files etc.
 		/// </summary>
 		private static string basePath = "c:\\";
 
 		/// <summary>
 		/// Alle Konfigurationsdaten
 		/// </summary>
 		internal Config m_Config;
 
 		/// <summary>
 		/// Die Caches für das Hauptfenster
 		/// </summary>
 		internal GlobalCache m_Cache;
 
 		#endregion
 
 		#region Hilfsfelder für die Suche
 
 		/// <summary>
 		/// Speichert das zuletzt benutzte TreeView
 		/// </summary>
 		TreeView lastUsedView = null;
 		/// <summary>
 		/// Liste mit StuffItems, die bereits angezeigt wurden
 		/// </summary>
 		List<string> itemsAlreadyFound = new List<string>();
         /// <summary>
         /// Suchstring, nachdem zuletzt gesucht wurde
         /// </summary>
         string lastSearchString = string.Empty;
 
 		#endregion
 
 		#region Windows 7-Spezialitäten
 		/// <summary>
 		/// Zugriff auf Windows 7-Superbar
 		/// </summary>
 		ITaskbarList3 tbl = null;
 
 		private bool IsWin7 = Environment.OSVersion.Version.ToString().StartsWith("6.1");
 
 		#endregion
 
 		/// <summary>
 		/// Konstruktor für das Formular
 		/// </summary>
 		public MainForm()
 		{
 			InitializeComponent();
 		}
 
 		/// <summary>
 		/// On Load Config ausführen
 		/// </summary>
 		/// <param name="sender"></param>
 		/// <param name="e"></param>
 		private void MainForm_Load(object sender, EventArgs e)
 		{
 			// Pfad zur Datei ermitteln
 			basePath = Application.ExecutablePath.Substring(0, Application.ExecutablePath.LastIndexOf("\\") + 1);
 
 			// Konfiguration von Platte einlesen
 			m_Config = new Config(basePath);
 
 			// Programm mit niedriger Priorität ausführen
 			if (m_Config.IsLowerPriority)
 			{
 				Process.GetCurrentProcess().PriorityClass = ProcessPriorityClass.BelowNormal;
 			}
 
 			// Fenstertitel setzen
 			if (!string.IsNullOrEmpty(m_Config.HeaderExtension))
 			{
                 Text = String.Format("[{0}] {1}", m_Config.HeaderExtension, DefaultHeader);
 			}
 			else
 			{
                 Text = DefaultHeader;
 			}
 
 			// Daten von der Platte einlesen
 			m_Cache = new GlobalCache(basePath);
 			
 			// Menüs erweitern
 			AddFremdePlattenMenu(MainMenuFremdePlatten.DropDownItems);
 			AddEigenePlattenMenu(MainMenuEigenePlatten.DropDownItems);
 
 			// wenn eine DefaultOfflineDatei hinterlegt ist
 			if (!String.IsNullOrEmpty(m_Config.DefaultOfflineFile))
 			{
 				if (File.Exists(m_Config.DefaultOfflineFile))
 				{
 					m_MyDisks.LoadOfflineCacheFromFile(m_Config.DefaultOfflineFile);
 				}
 				else
 				{
 					LogError("DefaultOfflineDatei " + m_Config.DefaultOfflineFile + " existiert nicht.");
 				}
 			}
 
 			// Standardeinstellungen für den "Meine Platten"-Tree anlegen
 			myDisksTree.AfterCheck += new TreeViewEventHandler(TransferCheckToStuffItem);
 			myDisksTree.TreeViewNodeSorter = (IComparer)new StuffItemSorter();
 
 			// Standardeinstellungen für den "Andere Platten"-Tree anlegen
 			otherDisksTree.AfterCheck += new TreeViewEventHandler(TransferCheckToStuffItem);
 			otherDisksTree.TreeViewNodeSorter = (IComparer)new StuffItemSorter();
 
 			StartUpdate();
 
 			// nur Windows 7/Server 2008 R2
 			if (IsWin7)
 			{
 				tbl = (ITaskbarList3)new TaskbarList();
 			}
 		}
 
 		/// <summary>
 		/// Kopiert eine Liste von Dateien an den angegebenen Zielort
 		/// </summary>
 		/// <param name="state"></param>
 		public void CopyFiles(object state)
 		{
 			// Thread-Zähler erhöhen
 			copyThreadCount++;
 
 			// Fehlerzähler
 			int errorCount = 0;
 			// Zähler für die kopierten Dateien
 			int copiedFileCount = 0;
 			float copiedFileSizeMB = 0;
 
 			List<StuffItemPair> copylist = (List<StuffItemPair>)state;
 
 			if (copylist.Count < 1)
 				return;
 
 			// Größe aller Dateien für die Einrichtung des Fortschrittsbalkens ermitteln
 			float allFileSizeMB = 0;
 			foreach (StuffItemPair pair in copylist)
 			{
 				try
 				{
 					FileInfo sourceInfo = new FileInfo(pair.Source.Path);
 					allFileSizeMB += sourceInfo.Length / 1024 / 1024;
 				}
 				catch { }
 				{
 					// mit 1 vorbelegen wegen division durch 0
 					if (allFileSizeMB == 0)
 						allFileSizeMB = 1;
 				}
 			}
 
 			// Setzen des Maximalwerts des Fortschrittsbalkens
 			maxProgressMB += allFileSizeMB;
 
 			Progress(copyThreadCount + "|0");
 
 			DateTime startTime = DateTime.Now;
 
 			// jede Datei kopieren
 			foreach (StuffItemPair sip in copylist)
 			{
 				float sourceSizeMB = 0;
 				try
 				{
 					// Quelle und Ziel bestimmen
 					string source = sip.Source.Path;
 					string target = Path.Combine(sip.Target.Path, Path.GetFileName(sip.Source.Path));
 
 					// Dateigröße der Quelldatei bestimmen
 					try
 					{
 						FileInfo sourceInfo = new FileInfo(source);
 						sourceSizeMB = (sourceInfo.Length / 1024 / 1024);
 					}
 					catch (Exception ex)
 					{
 						sourceSizeMB = 0;
 						LogWarning("Fehler: Größe der Datei " + source + " konnte nicht ermittelt werden: " + ex.Message);
 					}
 
 					// Dateianzahl erhöhen
 					copiedFileCount++;
 
 					Status("Kopiere Datei " + copiedFileCount.ToString() + " von " + copylist.Count.ToString() + ": " + source + " -> " + target + " (" + sourceSizeMB.ToString() + " MB)");
 					Log("Kopiere Datei " + copiedFileCount.ToString() + " von " + copylist.Count.ToString() + ": " + source + " -> " + target + " (" + sourceSizeMB.ToString() + " MB)");
 					try
 					{
 						Directory.CreateDirectory(sip.Target.Path);
 					}
 					catch (Exception ee)
 					{
 						LogError("Fehler beim Erstellen des Verzeichnisses: " + ee.Message);
 					}
 					File.Copy(source, target);
 					// Markierung entfernen
 					sip.Source.Checked = false;
 				}
 				catch (Exception e)
 				{
 					LogError("Fehler beim Kopieren der Datei " + sip.Source.Path + " : " + e.Message);
 					errorCount++;
 				}
 				finally
 				{
 					// Fortschritt aktualisieren
 					copiedFileSizeMB += sourceSizeMB;
 					Progress(copyThreadCount + "|" + sourceSizeMB);
 				}
 			}
 
 			// Thread-Zähler verringern
 			copyThreadCount--;
 
 			// Fortschrittsbalkenmaximum verringern
 			maxProgressMB -= allFileSizeMB;
 			currentProgressMB -= copiedFileSizeMB;
 
 			// Fortschrittsbalken zurücksetzen
 			Progress(copyThreadCount + "|0");
 
 			DateTime endTime = DateTime.Now;
 
 			// Anzeige der eigenen Platten aktualisieren
 			m_MyDisks.UpdateChildsBackground();
 
 			Status("Kopieren abgeschlossen! " + errorCount.ToString() + " von " + copylist.Count.ToString() + " Dateien konnten nicht kopiert werden.");
 
 			// Meldung über Kopiervorgang anzeigen
 			TimeSpan copyTime = endTime - startTime;
 			LogHighlight("Kopiervorgang abgeschlossen! Dateien kopiert: " + copiedFileCount + " - Gesamtgröße: " + String.Format("{0:F2}", copiedFileSizeMB) + " MB - Dauer: " + String.Format("{0:F0}:{1:D2}:{2:D2}", copyTime.TotalHours, copyTime.Minutes, copyTime.Seconds) + " - Transferrate: " + String.Format("{0:F2}", copiedFileSizeMB / copyTime.TotalSeconds) + " MB/s");
 			Message("Kopiervorgang abgeschlossen!" + Environment.NewLine + Environment.NewLine + "Dateien kopiert:\t" + copiedFileCount + Environment.NewLine + "Gesamtgröße:\t" + String.Format("{0:F2}", copiedFileSizeMB) + " MB" + Environment.NewLine + "Dauer:\t\t" + String.Format("{0:F0}:{1:D2}:{2:D2}", copyTime.TotalHours, copyTime.Minutes, copyTime.Seconds) + Environment.NewLine + "Transferrate:\t" + String.Format("{0:F2}", copiedFileSizeMB / copyTime.TotalSeconds) + " MB/s");
 		}
 
 		#region Klicks auf Menuepunkte
 
 		/// <summary>
 		/// KLick auf Exit
 		/// </summary>
 		/// <param name="sender"></param>
 		/// <param name="e"></param>
 		private void exitToolStripMenuItem_Click(object sender, EventArgs e)
 		{
 			Application.Exit();
 		}
 		
 		/// <summary>
 		/// Klick auf "Ordner aktualisieren"
 		/// </summary>
 		/// <param name="sender"></param>
 		/// <param name="e"></param>
 		private void UpdateFolderClick(object sender, EventArgs e)
 		{
 			GetStuffItem(sender).UpdateChildsBackground();
 		}
 
 		/// <summary>
 		/// Klick auf "Löschen des Logs"
 		/// </summary>
 		/// <param name="sender"></param>
 		/// <param name="e"></param>
 		private void protokollausgabeLöschenToolStripMenuItem_Click(object sender, EventArgs e)
 		{
             logTextBox.Clear();
 		}
 
 		/// <summary>
 		/// Konfiguration aufrufen und bei OK gleich scannen
 		/// </summary>
 		/// <param name="sender"></param>
 		/// <param name="e"></param>
 		private void konfigurationToolStripMenuItem_Click(object sender, EventArgs e)
 		{
 			if (m_Config.EditConfig())
 			{
 				StartUpdate();
 			}
 		}
 
 		/// <summary>
 		/// Eigene Platten erneut einlesen (z.zt nur default Konfiguration)
 		/// </summary>
 		/// <param name="sender"></param>
 		/// <param name="e"></param>
 		private void eigenePlattenAktualisierenToolStripMenuItem_Click(object sender, EventArgs e)
 		{
 			m_MyDisks.UpdateChildsBackground();
 		}
 
 		/// <summary>
 		/// Erneutes einlesen der fremden Platte
 		/// </summary>
 		/// <param name="sender"></param>
 		/// <param name="e"></param>
 		private void fremdePlatteAktualisierenToolStripMenuItem_Click(object sender, EventArgs e)
 		{
 			Program.MainWindow.m_OtherDisks.UpdateChildsBackground();
 		}
 
 		/// <summary>
 		/// Löschen des Hash-Caches (Datei löschen ginge auch ;-)
 		/// </summary>
 		/// <param name="sender"></param>
 		/// <param name="e"></param>
 		private void hashCacheLöschenToolStripMenuItem_Click(object sender, EventArgs e)
 		{
 			m_Cache.Clear();
 		}
 
 		#endregion
 
 		#region Aktualisierung der Bäume (von Hintergrundthread aufrufbar)
 
 		/// <summary>
 		/// Henkel um von einem Background-Prozess die Trees wieder zu aktualisieren
 		/// </summary>
 		public void UpdateTrees()
 		{
 			if ( InvokeRequired )
 			{
                 Invoke( new MethodInvoker(UpdateTrees));
 			}
 			else
 			{
 				UpdateMyDisksTreesInvoked(false);
 				UpdateOtherDisksTreesInvoked(false);
 			}
 		}
 
 		/// <summary>
 		/// Henkel um von einem Background-Prozess die Trees wieder zu aktualisieren
 		/// Dabei werden unmarkierte und Zweige ohne Fehler zugeklappt
 		/// </summary>
 		public void CollapseMyDisks()
 		{
 			if ( InvokeRequired )
 			{
                 Invoke( new MethodInvoker(CollapseMyDisks));
 			}
 			else
 			{
 				UpdateMyDisksTreesInvoked(true);
 			}
 		}
 
 		/// <summary>
 		/// Henkel um von einem Background-Prozess die Trees wieder zu aktualisieren
 		/// Dabei werden unmarkierte und Zweige ohne Fehler zugeklappt
 		/// </summary>
 		public void CollapseOtherDisks()
 		{
 			if ( InvokeRequired )
 			{
                 Invoke( new MethodInvoker(CollapseOtherDisks));
 			}
 			else
 			{
 				UpdateOtherDisksTreesInvoked(true);
 			}
 		}
 
 		/// <summary>
 		/// Nur im Invoke-Zyklus rufbar!
 		/// </summary>
 		/// <param name="autoCollapse"></param>
 		private void UpdateMyDisksTreesInvoked(bool autoCollapse)
 		{
 			if ( InvokeRequired )
 			{
 				throw new Exception("Dieser Aufruf ist nur im Invoke-Zylus erlaubt");
 			}
 			
 			myDisksTree.BeginUpdate();
 
 			if (myDisksTree.Nodes.Count == 0)
 			{
 				myDisksTree.Nodes.Add(new TreeNode());
 			}
 
 			UpdateTreeRecursive( myDisksTree.Nodes[ 0 ], m_MyDisks, autoCollapse );
 			
 			myDisksTree.Nodes[0].Expand();
 			myDisksTree.Sort();
 	
 			myDisksTree.EndUpdate();
 			Status("Aktualisierung abgeschlossen!");
 		}
 
 		/// <summary>
 		/// Nur im Invoke-Zyklus rufbar!
 		/// </summary>
 		/// <param name="autoCollapse"></param>
 		private void UpdateOtherDisksTreesInvoked(bool autoCollapse)
 		{
 			if (this.InvokeRequired)
 			{
 				throw new Exception("Dieser Aufruf ist nur im Invoke-Zylus erlaubt");
 			}
 			//---Rechter Baum
 			
 			otherDisksTree.BeginUpdate();
 			if (otherDisksTree.Nodes.Count == 0)
 			{
 				otherDisksTree.Nodes.Add(new TreeNode());
 			}
 
 			UpdateTreeRecursive(otherDisksTree.Nodes[0], Program.MainWindow.m_OtherDisks, autoCollapse);
 			
 			otherDisksTree.Nodes[0].Expand();
 			otherDisksTree.Sort();
 			otherDisksTree.EndUpdate();
 			Status("Aktualisierung abgeschlossen!");
 		}
 
 		/// <summary>
 		/// Checkboxstatus bei Änderungen in StuffItem (im Tag) übertragen
 		/// </summary>
 		/// <param name="sender"></param>
 		/// <param name="e"></param>
 		void TransferCheckToStuffItem(object sender, TreeViewEventArgs e)
 		{
 			StuffItem si = (StuffItem)e.Node.Tag;
 
 			if (si != null)
 			{
 				si.Checked = e.Node.Checked;
 			}
 		}
 		
 		/// <summary>
 		/// TreeNode aus StuffItem aktualisieren (Rekursiv)
 		/// </summary>
 		/// <param name="tn">Node</param>
 		/// <param name="si">Item</param>
 		/// <param name="autoCollapse">Automatisch zuklappen</param>
 		private void UpdateTreeRecursive(TreeNode tn, StuffItem si, Boolean autoCollapse)
 		{
 			List<string> delKeys = new List<string>();
 
 			// StuffItem immer in Tag hängen
 			tn.Tag = si;
 			// Mit AutoCollapse erst mal alles zuklappen und nur bei Bedarf wieder öffnen
 			if (autoCollapse)
 			{
 				tn.Collapse();
 			}
 			// Sicherstellen, dass Fehler und Markierungen immer sichtbar sind,
 			// erlaubte Dubletten nicht immer sichtbar machen
 			if ((si.HasClones && (!si.IsIgnored || m_Config.IsShowIgnoredClones)) || si.IsNeeded || si.Checked)
 			{
 				TreeNode pn = tn.Parent;
 				while (pn != null)
 				{
 					pn.Expand();
 					pn = pn.Parent;
 				}
 			}
 
 			tn.Text = si.Text;
 			tn.ImageIndex = tn.SelectedImageIndex = (int)si.Icon;
 			tn.ToolTipText = si.ToolTip;
 
 			// Checkboxes aus StuffItems setzen
 			tn.Checked = si.Checked;
 
 			// Offline duch Textfarbe anzeigen
 			tn.ForeColor = si.IsOnline ? Color.Black : Color.SteelBlue;
 
 			// Alle ChildItems durchlaufen, ggf. hinzufügen und rekursiv aktualisieren
 			foreach (StuffItem csi in si.ChildItems.ToArray())
 			{
 				// Wenn die Datei gesperrt/vorhanden ist und keine gesperrten/vorhandenen Dateien
 				// angezeigt werden sollen, dann gar nicht erst hinzufügen
 				if (!csi.IsVisible)
 				{
 					if (tn.Nodes.ContainsKey(csi.Path))
 					{
 						delKeys.Add(csi.Path);
 					}
 					continue;
 				}
 
 				// neuen Node anlegen, wenn noch nicht bekannt
 				if (!tn.Nodes.ContainsKey(csi.Path))
 				{
 					tn.Nodes.Add(csi.Path, csi.Name);
 				}
 				TreeNode ntn = tn.Nodes[csi.Path];
 				UpdateTreeRecursive(ntn, csi, autoCollapse);
 			}
 
 			// Alle TreeNodes löschen, die nicht mehr in den ChildItems sind (Das TreeNode.Tag zeigt auf das StuffItem)
 			foreach (TreeNode ntn in tn.Nodes)
 			{
 				if (!si.ChildItems.Contains((StuffItem)ntn.Tag))
 				{
 					delKeys.Add(((StuffItem)ntn.Tag).Path);
 				}
 			}
 
 			// Zweistufiges rauswerfen, damit die Liste nicht beim Durchlaufen manipuliert wird
 			foreach (string k in delKeys)
 			{
 				tn.Nodes.RemoveByKey(k);
 			}
 		}
 
 		#endregion
 
 		#region Logging/Messagebox/Status/Progress (auch von Hintergrundthreads nutzbar)
 
 		private delegate void MethodInvokerWithString(string s);
 
 		/// <summary>
 		/// Logausgabe. Diese Methode kann von Hintergrundthreads gerufen werden
 		/// </summary>
 		/// <param name="logText"></param>
 		public void Log(string logText)
 		{
 			if (this.InvokeRequired)
 			{
 				this.Invoke(new MethodInvokerWithString(Log), "*BG* " + logText);
 			}
 			else
 			{
 				logTextBox.SelectionColor = Color.Black;
 				LogMessage(logText);
 			}
 		}
 
 		/// <summary>
 		/// Logausgabe in Grün als Highlight. Diese Methode kann von Hintergrundthreads gerufen werden
 		/// </summary>
 		/// <param name="log"></param>
 		public void LogHighlight(string log)
 		{
 			if (this.InvokeRequired)
 			{
 				this.Invoke(new MethodInvokerWithString(LogHighlight), "*BG* " + log);
 			}
 			else
 			{
 				logTextBox.SelectionColor = Color.DarkGreen;
 				LogMessage(log);
 			}
 		}
 
 		/// <summary>
 		/// Logausgabe in Gelb als Warnung. Diese Methode kann von Hintergrundthreads gerufen werden
 		/// </summary>
 		/// <param name="log"></param>
 		public void LogWarning(string log)
 		{
 			if (this.InvokeRequired)
 			{
 				this.Invoke(new MethodInvokerWithString(LogWarning), "*BG* " + log);
 			}
 			else
 			{
 				logTextBox.SelectionColor = Color.Orange;
 				LogMessage(log);
 			}
 		}
 
 		/// <summary>
 		/// Logausgabe in Rot als Fehler. Diese Methode kann von Hintergrundthreads gerufen werden
 		/// </summary>
 		/// <param name="log"></param>
 		public void LogError(string log)
 		{
 			if (this.InvokeRequired)
 			{
 				this.Invoke(new MethodInvokerWithString(LogError), "*BG* " + log);
 			}
 			else
 			{            
 				logTextBox.SelectionColor = Color.Red;
 				LogMessage(log);
 			}
 		}
 
 		private void LogMessage(string message)
 		{
 			if (String.IsNullOrEmpty(message))
 				logTextBox.AppendText("\r\n");
 			else
 				logTextBox.AppendText("\r\n" + DateTime.Now.ToString() + " | " + message);
 
 			logTextBox.ScrollToCaret();
 			logTextBox.Refresh();
 		}
 
 		/// <summary>
 		/// Statustext ausgeben
 		/// </summary>
 		/// <param name="message">Nachricht, die in der Statuszeile ausgegeben werden soll</param>
 		public void Status(string message)
 		{
 			if (this.InvokeRequired)
 			{
 				this.Invoke(new MethodInvokerWithString(Status), message);
 			}
 			else
 			{
 				stsStatus.Items[0].Text = message;
 			}
 		}
 
 		/// <summary>
 		/// Messagebox ausgeben
 		/// </summary>
 		public void Message(string messageText)
 		{
 			if (this.InvokeRequired)
 			{
 				this.Invoke(new MethodInvokerWithString(Message), messageText);
 			}
 			else
 			{
 				MessageBox.Show(messageText, "Information", MessageBoxButtons.OK, MessageBoxIcon.Information);
 			}
 		}
 
 		/// <summary>
 		/// Progress anzeigen
 		/// </summary>
 		/// <param name="value">|</param>
 		public void Progress(string value)
 		{
 			if (this.InvokeRequired)
 			{
 				this.Invoke(new MethodInvokerWithString(Progress), value);
 			}
 			else
 			{
 				try
 				{
 					if (value is String)
 					{
 						String[] args = value.Split("|".ToCharArray());
 
 						if (args[0].Equals("0"))
 						{
 							statusProgress.Value = 0;
 
 							// nur Windows 7/Server 2008 R2
 							if (IsWin7)
 							{
 								tbl.SetProgressState(this.Handle, TBPFLAG.TBPF_NOPROGRESS);
 							}
 
 
 						}
 						else
 						{
 							// Fortschrittsbalken
 							if (maxProgressMB > 0)
 							{
 								// neuen Fortschritt an Hand der Dateigröße berechnen
 								currentProgressMB += Convert.ToInt32(args[1]);
 								int progressValue = (int)((currentProgressMB * 100) / maxProgressMB);
 								statusProgress.Value = progressValue;
 								statusProgress.ToolTipText = "Fortschritt: " + progressValue + " % (" + currentProgressMB +
 									" MB von " + maxProgressMB + " MB";
 
 								// nur Windows 7/Server 2008 R2
 								if (IsWin7)
 								{
 									tbl.SetProgressValue(this.Handle, (ulong)progressValue, 100);
 								}
 							}
 						}
 
 						// Anzahl Threads
 						statusThreads.Text = "T: " + args[0];
 					}
 				}
 				catch
 				{
 					// ignore
 				}
 			}
 		}
 
 		#endregion
 
 		#region Drag & Drop
 
 		private void otherDisksTree_ItemDrag(object sender, ItemDragEventArgs e)
 		{
 			TreeNode tn = (TreeNode)e.Item;
 			if (tn != null /*&& ((StuffItem)tn.Tag).IsNeeded*/)
 			{
 				DoDragDrop(e.Item, DragDropEffects.Move);
 			}
 		}
 
 		private void myDisksTree_DragEnter(object sender, DragEventArgs e)
 		{
 			TreeNode trgt = myDisksTree.GetNodeAt(myDisksTree.PointToClient(new Point(e.X, e.Y)));
 			if (trgt != null && trgt.ImageIndex == (int)TreeNodeImage.Folder)
 			{
 				e.Effect = DragDropEffects.Move;
 			}
 			else
 			{
 				e.Effect = DragDropEffects.None;
 			}
 		}
 
 		private void myDisksTree_DragDrop(object sender, DragEventArgs e)
 		{
 			// Source und Target aus dem Drag&Drog-Object ermitteln
 			TreeNode src = (TreeNode)e.Data.GetData(typeof(TreeNode));
 			TreeNode trgt = myDisksTree.GetNodeAt(myDisksTree.PointToClient(new Point(e.X, e.Y)));
 			List<StuffItemPair> copylist = new List<StuffItemPair>();
 			copylist.Add(new StuffItemPair());
 			copylist[0].Source = ((StuffItem)src.Tag);
 			copylist[0].Target = ((StuffItem)trgt.Tag);
 
 			Program.RunBackgroundTask(this, "CopyFiles", copylist);
 		}
 
 		#endregion
 
 		#region Funktionen für die Arbeit mit MainMenü / PopupMenü
 
 		/// <summary>
 		/// Einhängen eines Menüpunktes mit Event, Bild (opt) und StuffItem
 		/// </summary>
 		private void AddToMenuCollection(ToolStripItemCollection menuCollection, string name, string image, EventHandler eventHandler, StuffItem stuffItem)
 		{
 			ToolStripItem ts = menuCollection.Add(name);
 			ts.Click += eventHandler;
 			ts.Tag = stuffItem;
 			if (image != null && fileSystemImageList.Images.ContainsKey(image))
 			{
 				ts.Image = fileSystemImageList.Images[image];
 			}
 		}
 
 		/// <summary>
 		/// StuffItem aus ToolStripItem oder MenuItem extrahieren (damit können Events
 		/// von beiden Menüs aus verwendet werden)
 		/// </summary>
 		/// <param name="menuItem"></param>
 		/// <returns></returns>
 		private static StuffItem GetStuffItem(object menuItem)
 		{
 			if (menuItem is MenuItem)
 			{
 				return (StuffItem)((MenuItem)menuItem).Tag;
 			}
 
 			if (menuItem is ToolStripItem)
 			{
 				return (StuffItem)((ToolStripItem)menuItem).Tag;
 			}
 
 			return null;
 		}
 
 		/// <summary>
 		/// Menü für eigene Platten aufbauen (Hauptmenü und Popup-Menü)
 		/// </summary>
 		/// <param name="menuCollection"></param>
 		private void AddEigenePlattenMenu(ToolStripItemCollection menuCollection)
 		{
 			// Konfiguration öffnen
 			AddToMenuCollection(menuCollection, "Platten hinzufügen oder entfernen...", "Hinzufuegen.png", new EventHandler(konfigurationToolStripMenuItem_Click), m_MyDisks);
 			// Menüpunkt für Aktualisieren links
 			AddToMenuCollection(menuCollection, "Meine Platten aktualisieren", "Aktualisieren.png", new EventHandler(eigenePlattenAktualisierenToolStripMenuItem_Click), m_MyDisks);
 			// Online / Offline Wechsel
 			AddToMenuCollection( menuCollection, "Meine Platten " + ( m_MyDisks.IsOnline ? "offline" : "online" ) + " schalten", m_MyDisks.IsOnline ? "DateiWeiss.png" : "DateiGruen.png", new EventHandler( ToggleOnline ), m_MyDisks );
 			// Separator
 			menuCollection.Add("-");
 			// Markieren aller Dateien ab Root, die gelöscht werden können
 			AddToMenuCollection(menuCollection, "Dubletten zum Löschen markieren (eine bleibt)", "Markieren.png", new EventHandler(ContextMarkDoubleEntries), m_MyDisks);
 			// Allgemeines Menü für alle Platten dazu
 			AddAllePlattenMenu( menuCollection, m_MyDisks );
 			// Löschen aller links makierten Dateien
 			AddToMenuCollection(menuCollection, "Alle markierten Dateien sperren und löschen", "DateiExcludedAndDeleted.png", new EventHandler(ContextExcludeAndDeleteAllMarkedFiles), m_MyDisks);
 			AddToMenuCollection(menuCollection, "Alle markierten Dateien löschen", "DateiLoeschen.png", new EventHandler(ContextDeleteAllMarkedFiles), m_MyDisks);
 		}
 
 		/// <summary>
 		/// Menü für fremde Platten aufbauen (Hauptmenü und Popup-Menü)
 		/// </summary>
 		/// <param name="menuCollection"></param>
 		private void AddFremdePlattenMenu(ToolStripItemCollection menuCollection)
 		{      
 			// Konfiguration öffnen
 			AddToMenuCollection(menuCollection, "Platten hinzufügen oder entfernen...", "Hinzufuegen.png", new EventHandler(konfigurationToolStripMenuItem_Click), Program.MainWindow.m_OtherDisks);
 			// AddToMenuCollection(menuCollection, "Fremde Platte hinzufügen...", "Hinzufuegen.png", new EventHandler(FremdePlatteAuswaehlenClick), Program.MainWindow.m_OtherDisks);
 			// Menüpunkt für Aktualisieren rechts
 			AddToMenuCollection(menuCollection, "Fremde Platten aktualisieren", "Aktualisieren.png", new EventHandler(fremdePlatteAktualisierenToolStripMenuItem_Click), Program.MainWindow.m_OtherDisks);
 			// Online / Offline Wechsel
 			AddToMenuCollection(menuCollection, "Fremde Platten " + (Program.MainWindow.m_OtherDisks.IsOnline ? "offline" : "online") + " schalten", Program.MainWindow.m_OtherDisks.IsOnline ? "DateiWeiss.png" : "DateiGruen.png", new EventHandler(ToggleOnline), Program.MainWindow.m_OtherDisks);
 			// Separator
 			menuCollection.Add("-");
 			// Markieren aller zu saugenden Dateien ab Root
 			AddToMenuCollection(menuCollection, "Alle fehlenden Dateien markieren", "Markieren.png", new EventHandler(ContextMarkMissingFiles), Program.MainWindow.m_OtherDisks);
 			// Allgemeines Menü für alle Platten dazu
 			AddAllePlattenMenu(menuCollection, Program.MainWindow.m_OtherDisks);
 		}
 
 		/// <summary>
 		/// Menü für beide Platten, wird von AddFremde/EigenenPlattenMenu verwendet
 		/// </summary>
 		/// <param name="menuCollection"></param>
 		/// <param name="stuffItem"></param>
 		private void AddAllePlattenMenu(ToolStripItemCollection menuCollection, StuffItem stuffItem)
 		{
 			// Markieren aller Dateien ab Root
 			AddToMenuCollection(menuCollection, "Alle Dateien markieren", "Markieren.png", new EventHandler(ContextMark), stuffItem);
 			// Markierung mit Suchfilter setzen
 			AddToMenuCollection(menuCollection, "Dateien mit Suchfilter markieren...", "Markieren.png", new EventHandler(ContextMarkByFilter), stuffItem);
 			// Markierung entfernen aller Dateien ab Root
 			AddToMenuCollection(menuCollection, "Alle Markierungen entfernen", "Demarkieren.png", new EventHandler(ContextRemoveMark), stuffItem);
 			// Separator
 			menuCollection.Add("-");
 			// Unbenötigte Teile zuklappen
 			AddToMenuCollection(menuCollection, "Alle Ordner ohne Markierungen/Hinweise zuklappen", "Zuklappen.png", new EventHandler(ContextCollapse), stuffItem);
 			// Separator
 			menuCollection.Add("-");
 			// Markieren/Demarkieren
 			AddToMenuCollection(menuCollection, "Alle markierten Dateien entsperren", "DateiFrischGesaugt.png", new EventHandler(ContextIncludeMarkers), stuffItem);
 			AddToMenuCollection(menuCollection, "Alle markierten Dateien sperren", "DateiExcluded.png", new EventHandler(ContextExcludeMarkers), stuffItem);
 		}
 
 		/// <summary>
 		/// Kontextmenu aufbauen
 		/// </summary>
 		/// <param name="sender"></param>
 		/// <param name="e"></param>
 		private void tree_MouseUp( object sender, MouseEventArgs e )
 		{
 			TreeView tv = ( TreeView )sender;
 			if ( e.Button != MouseButtons.Right )
 			{
 				return;
 			}
 
 			Point clickPoint = new Point( e.X, e.Y );
 			TreeNode clickNode = tv.GetNodeAt( clickPoint );
 			if ( clickNode == null )
 			{
 				return;
 			}
 
 			StuffItem clickItem = ( StuffItem )clickNode.Tag;
 			bool isRoot = clickItem.Equals( m_MyDisks ) || clickItem.Equals( Program.MainWindow.m_OtherDisks );
 			// Convert from Tree coordinates to Screen coordinates
 			Point ScreenPoint = tv.PointToScreen( clickPoint );
 			// Convert from Screen coordinates to Form coordinates
 			Point FormPoint = this.PointToClient( ScreenPoint );
 
 			// Show context menu
 			ContextMenuStrip contextmenu = new ContextMenuStrip();
 			contextmenu.Items.Clear();
 			// Fremde Platte entfernen
 
 			// Menüs für die 
 			if ( isRoot )
 			{
 				if ( !clickItem.IsOnForeignDisk )
 				{
 					AddEigenePlattenMenu( contextmenu.Items );
 				}
 				else
 				{
 					AddFremdePlattenMenu( contextmenu.Items );
 				}
 			}
 			else
 			{
 				if ( !clickItem.IsFile )
 				{
 					AddToMenuCollection( contextmenu.Items, "Ordner " + clickItem.Path + " aktualisieren" + ( clickItem.IsOnline ? "" : " (offline)" ), "Aktualisieren.png", new EventHandler( UpdateFolderClick ), clickItem );
 					AddToMenuCollection( contextmenu.Items, "Ordner " + clickItem.Path + ( clickItem.IsOnline ? " offline" : " online" ) + " schalten", clickItem.IsOnline ? "DateiWeiss.png" : "DateiGruen.png", new EventHandler( ToggleOnline ), clickItem );
 					contextmenu.Items.Add( "-" );
 				}
 				// Menüpunkt für Ansehen
 				if ( !clickItem.HasReadError )
 				{
 					AddToMenuCollection( contextmenu.Items, "Öffnen", "Oeffnen.png", new EventHandler( ContextExecute ), clickItem );
 					// Öffnen mit Anbieten bei Dateien
 					if ( clickItem.IsFile )
 					{
 						AddToMenuCollection( contextmenu.Items, "Öffnen mit...", "Oeffnen.png", new EventHandler( ContextExecuteWith ), clickItem );
 					}
 				}
 
 				// Ordner mit Unterordnern
 				if ( !clickItem.IsFile && clickItem.ChildItems.Count > 0 )
 				{
 					contextmenu.Items.Add( "-" );
 					// Markieren aller Dateien ab Folder
 					AddToMenuCollection( contextmenu.Items, "Alle Dateien unterhalb " + clickItem.Path + " markieren", "Markieren.png", new EventHandler( ContextMark ), clickItem );
 					// Markieren aller Dateien ab Folder mit Filter
 					AddToMenuCollection( contextmenu.Items, "Dateien unterhalb " + clickItem.Path + " mit Suchfilter markieren...", "Markieren.png", new EventHandler( ContextMarkByFilter ), clickItem );
 					// Markieren aller zu saugenden Dateien ab Folder
 					if ( clickItem.IsOnForeignDisk )
 					{
 						AddToMenuCollection( contextmenu.Items, "Alle fehlenden Dateien unterhalb " + clickItem.Path + " markieren", "Markieren.png", new EventHandler( ContextMarkMissingFiles ), clickItem );
 					}
 					// Markierung entfernen aller Dateien ab Folder
 					AddToMenuCollection( contextmenu.Items, "Alle Markierungen unterhalb " + clickItem.Path + " entfernen", "Demarkieren.png", new EventHandler( ContextRemoveMark ), clickItem );
 				}
 
 				if ( !clickItem.IsOnForeignDisk && !clickItem.IsFile && !clickItem.HasReadError )
 				{
 					contextmenu.Items.Add( "-" );
 					// Kopieren aller rechts markierten Dateien in einen Folder (flat)
 					AddToMenuCollection( contextmenu.Items, "Alle fremden selektierten Dateien direkt in diesen Ordner kopieren (flat)", "DateiSaugen.png", new EventHandler( ContextCopyAllClick ), clickItem );
 					// Kopieren aller rechts markierten Dateien in einen Folder (hierarchisch)
 					AddToMenuCollection( contextmenu.Items, "Alle fremden selektierten Dateien mit Ordnerstruktur in diesen Ordner kopieren", "DateiSaugen.png", new EventHandler( ContextCopyAllWithFoldersClick ), clickItem );
 					// Ordner anlegen
 					AddToMenuCollection( contextmenu.Items, "Neuen Ordner unterhalb " + clickItem.Path + " anlegen", "Ordner.png", new EventHandler( ContextNewFolder ), clickItem );
 
 				}
 
 				if ( clickItem.IsFile && clickItem.HasClones )
 				{
 					contextmenu.Items.Add( "-" );
 
 					List<StuffItem> clones = Program.MainWindow.m_MyDisks.GetItemClones( clickItem );
 					for ( int i = 0 ; i < clones.Count ; i++ )
 					{
 						if ( !clones[ i ].Equals( clickItem ) )
 						{
 							AddToMenuCollection( contextmenu.Items, "Öffnen Dublette " + clones[ i ].Path, "Oeffnen.png", new EventHandler( ContextExecute ), clones[ i ] );
 						}
 					}
 
 					AddToMenuCollection( contextmenu.Items, "Markieren aller Dubletten dieser Datei", "Markieren.png", new EventHandler( ContextMarkClones ), clickItem );
 					// Dubletten ignorieren ja/nein
 					if ( !clickItem.IsIgnored )
 					{
 						AddToMenuCollection( contextmenu.Items, "Dubletten dieser Datei erlauben", "", new EventHandler( ContextIgnore ), clickItem );
 					}
 					else
 					{
 						AddToMenuCollection( contextmenu.Items, "Dubletten dieser Datei wieder markieren", "", new EventHandler( ContextUnIgnore ), clickItem );
 					}
 
 					// Für Dubletten Menüs anbieten (auf rot)
 					for ( int i = 0 ; i < clones.Count ; i++ )
 					{
 						if ( !clones[ i ].Equals( clickItem ) )
 						{
 							AddToMenuCollection( contextmenu.Items, "Löschen Dublette " + clones[ i ].Path, "DateiLoeschen.png", new EventHandler( ContextDeleteFile ), clones[ i ] );
 						}
 					}
 
 				}
 				// Datei in die Sperrliste ein-/austragen
 				if ( clickItem.IsFile )
 				{
 					// Linie nach Markieren
 					contextmenu.Items.Add( "-" );
 					if ( !clickItem.IsExcluded )
 					{
 						AddToMenuCollection( contextmenu.Items, "Sperren der Datei", "DateiExcluded.png", new EventHandler( ContextExclude ), clickItem );
 					}
 					else
 					{
 						AddToMenuCollection( contextmenu.Items, "Entsperren der Datei", "DateiFrischGesaugt.png", new EventHandler( ContextInclude ), clickItem );
 					}
 					// Sperren und zugleich löschen
 					if ( !clickItem.IsExcluded && !clickItem.IsOnForeignDisk )
 					{
 						AddToMenuCollection( contextmenu.Items, "Sperren und Löschen der Datei", "DateiExcludedAndDeleted.png", new EventHandler( ContextExcludeAndDelete ), clickItem );
 					}
 					// Löschen einer Einzeldatei, nur links
 					if ( !clickItem.IsOnForeignDisk )
 					{
 						AddToMenuCollection( contextmenu.Items, "Löschen der Datei", "DateiLoeschen.png", new EventHandler( ContextDeleteFile ), clickItem );
 					}
 				}
 				// Löschen eines (leeren) Ordners
 				if ( !clickItem.HasReadError && !clickItem.IsOnForeignDisk && !clickItem.IsFile && clickItem.ChildItems.Count == 0 )
 				{
 					AddToMenuCollection( contextmenu.Items, "Ordner löschen", "OrdnerLoeschen.png", new EventHandler( ContextDeleteFolder ), clickItem );
 				}
 				// Sperren/Entsperren multi
 				if ( !clickItem.IsFile && clickItem.ChildItems.Count > 0 )
 				{
 					// Linie nach Markieren
 					contextmenu.Items.Add( "-" );
 					AddToMenuCollection( contextmenu.Items, "Alle markierten Dateien entsperren", "DateiFrischGesaugt.png", new EventHandler( ContextIncludeMarkers ), clickItem );
 					AddToMenuCollection( contextmenu.Items, "Alle markierten Dateien sperren", "DateiExcluded.png", new EventHandler( ContextExcludeMarkers ), clickItem );
 					AddToMenuCollection( contextmenu.Items, "Alle markierten Dateien sperren und löschen", "DateiExcludedAndDeleted.png", new EventHandler( ContextExcludeAndDeleteAllMarkedFiles ), clickItem );
 					// Löschen aller links markierten Dateien
 					if ( !clickItem.IsOnForeignDisk )
 					{
 						AddToMenuCollection( contextmenu.Items, "Alle markierten Dateien unterhalb " + clickItem.Path + " löschen", "DateiLoeschen.png", new EventHandler( ContextDeleteAllMarkedFiles ), clickItem );
 					}
 				}
 			}
 			contextmenu.Show( this, FormPoint );
 		}
 
 		#endregion
 
 		#region Popup Menü Aktionen
 
 		/// <summary>
 		/// Teilbaum von Offline auf Online und umgekehrt setzen
 		/// </summary>
 		/// <param name="sender"></param>
 		/// <param name="e"></param>
 		void ToggleOnline(object sender, EventArgs e)
 		{
 			// StuffItem ermitteln
 			StuffItem si = GetStuffItem(sender);
 			if (si == null)
 			{
 				return;
 			}
 			
 			// Onlinestatus umsetzen
 			if (si.IsOnline)
 			{
 				Log("Setze Offline: " + si.Path);
 				si.IsOnline = false;
 			}
 			else
 			{
 				Log("Setze Online: " + si.Path);
 				si.IsOnline = true;
 			}
 
 			// Menüs bauen sich dabei um!
 			MainMenuFremdePlatten.DropDownItems.Clear();
 			AddFremdePlattenMenu(MainMenuFremdePlatten.DropDownItems);
 			MainMenuEigenePlatten.DropDownItems.Clear();
 			AddEigenePlattenMenu(MainMenuEigenePlatten.DropDownItems);
 			
 			UpdateTrees();
 		}
 
 		/// <summary>
 		/// Eine Datei excluden
 		/// </summary>
 		/// <param name="sender"></param>
 		/// <param name="e"></param>
 		void ContextExclude(object sender, EventArgs e)
 		{
 			try
 			{
 				StuffItem si = GetStuffItem(sender);
 				// wenn kein StuffItem ausgewählt wurde, dann tun wir hier nix
 				if (si == null)
 				{
 					return;
 				}
 
 				// Datei sperren
 				si.Exclude();
 				Log("Sperre Datei: " + si.Path);
 
 				UpdateTreeNodeIcon(si);
 			}
 			catch (Exception e2)
 			{
 				LogError("Fehler beim Sperren: " + e2.Message);
 			}
 		}
 
 		/// <summary>
 		/// Eine Datei excluden und löschen
 		/// </summary>
 		/// <param name="sender"></param>
 		/// <param name="e"></param>
 		void ContextExcludeAndDelete( object sender, EventArgs e )
 		{
 			try
 			{
 				StuffItem si = GetStuffItem( sender );
 				if ( si == null )
 				{
 					return;
 				}
 				DialogResult res = MessageBox.Show( "Datei " + si.Name + " wirklich sperren und löschen?", 
 					"Vorsicht, sie trennen sich von Material!", MessageBoxButtons.OKCancel, MessageBoxIcon.Exclamation );
 				if ( res == DialogResult.OK )
 				{
 					Log( "Sperre und lösche Datei: " + si.Path );
 					si.Exclude();
 					File.Delete( si.Path );
 
 					RemoveStuffItemFromMyDisksTree( si );
 				}
 			}
 			catch ( Exception e2 )
 			{
 				LogError( "Fehler beim Sperren und Löschen: " + e2.Message );
 			}
 		}
 
 		/// <summary>
 		/// Eine Datei includen
 		/// </summary>
 		/// <param name="sender"></param>
 		/// <param name="e"></param>
 		void ContextInclude(object sender, EventArgs e)
 		{
 			try
 			{
 				StuffItem si = GetStuffItem(sender);
 				if (si == null)
 				{
 					return;
 				}
 
 				Log("Entsperre Datei: " + si.Path);
 				si.Include();
 
 				UpdateTreeNodeIcon(si);
 			}
 			catch (Exception ex)
 			{
 				LogError("Fehler beim Entsperren: " + ex.Message);
 			}
 		}
 
 
 		/// <summary>
 		/// Eine Datei ignorieren
 		/// </summary>
 		/// <param name="sender"></param>
 		/// <param name="e"></param>
 		void ContextIgnore(object sender, EventArgs e)
 		{
 			try
 			{
 				StuffItem si = GetStuffItem(sender);
 				if (si == null)
 				{
 					return;
 				}
 
 				Log("Erlaube Dubletten der Datei: " + si.Path);
 				si.Ignore();
 
 				// Icon der Datei und möglicher Clones anpassen
 				UpdateTreeNodeIcon(si);
 			}
 			catch (Exception ex)
 			{
 				LogError("Fehler beim Erlauben: " + ex.Message);
 			}
 		}
 
 		/// <summary>
 		/// Eine Datei un-ignorieren
 		/// </summary>
 		/// <param name="sender"></param>
 		/// <param name="e"></param>
 		void ContextUnIgnore(object sender, EventArgs e)
 		{
 			try
 			{
 				StuffItem si = GetStuffItem(sender);
 				if (si == null)
 				{
 					return;
 				}
 
 				Log("Markiere Dubletten der Datei: " + si.Path);
 				si.UnIgnore();
 
 				// Icon der Datei und möglicher Clones anpassen
 				UpdateTreeNodeIcon( si );
 			}
 			catch (Exception ex)
 			{
 				LogError("Fehler beim Markieren: " + ex.Message);
 			}
 		}
 
 		/// <summary>
 		/// Eine Datei ausführen durch Menüeintrag 
 		/// </summary>
 		/// <param name="sender"></param>
 		/// <param name="e"></param>
 		void ContextExecute(object sender, EventArgs e)
 		{
 			try
 			{
 				StuffItem si = GetStuffItem(sender);
 				if ( si == null )
 				{
 					return;
 				}
 				if ( si.IsFile )
 				{
 					Status( "Starte Datei: " + si.Path );
 				}
 				else
 				{
 					Status( "Öffne Verzeichnis: " + si.Path );
 				}
 
 				try
 				{
 					Process.Start(si.Path);
 				}
 				catch
 				{
 					ContextExecuteWith(sender, e);
 				}
 			}
 			catch (Exception e2)
 			{
 				LogError("Fehler beim Ausführen: " + e2.Message);
 			}
 		}
 
 		/// <summary>
 		/// Eine Datei ausführen mit Auswahl durch Programm durch Menüeintrag 
 		/// </summary>
 		/// <param name="sender"></param>
 		/// <param name="e"></param>
 		void ContextExecuteWith(object sender, EventArgs e)
 		{
 			try
 			{
 				StuffItem si = GetStuffItem(sender);
 				if ( si == null )
 				{
 					return;
 				}
 				if ( si.IsFile )
 				{
 					Status( "Starte Datei: " + si.Path );
 				}
 				else
 				{
 					Status( "Öffne Verzeichnis: " + si.Path );
 				}
 
 				using (Process p = new Process())
 				{
 					ProcessStartInfo pi = new ProcessStartInfo("rundll32.exe");
 					pi.UseShellExecute = false;
 					pi.RedirectStandardOutput = true;
 					pi.Arguments = "shell32.dll,OpenAs_RunDLL " + si.Path;
 					p.StartInfo = pi;
 					p.Start();
 				}
 			}
 			catch (Exception e2)
 			{
 				LogError("Fehler beim Ausführen: " + e2.Message);
 			}
 		}
 
 		/// <summary>
 		/// Eine Datei löschen
 		/// </summary>
 		/// <param name="sender"></param>
 		/// <param name="e"></param>
 		void ContextDeleteFile(object sender, EventArgs e)
 		{
 			try
 			{
 				StuffItem si = GetStuffItem(sender);
 				if (si == null)
 				{
 					return;
 				}
 
 				if (MessageBox.Show("Datei " + si.Name + " wirklich löschen?", "Vorsicht, sie trennen sich von Material!", 
 					MessageBoxButtons.OKCancel, MessageBoxIcon.Exclamation) == DialogResult.OK)
 				{
 					// Datei löschen
 					Log("Lösche Datei: " + si.Path);
 					File.Delete(si.Path);
 
 					RemoveStuffItemFromMyDisksTree( si );
 				}
 			}
 			catch (Exception e2)
 			{
 				LogError("Fehler beim Löschen: " + e2.Message);
 			}
 		}
 
 		/// <summary>
 		/// Eine leeren Ordner löschen
 		/// </summary>
 		/// <param name="sender"></param>
 		/// <param name="e"></param>
 		void ContextDeleteFolder(object sender, EventArgs e)
 		{
 			try
 			{
 				StuffItem si = GetStuffItem(sender);
 				if ( si == null )
 				{
 					return;
 				}
 
 				DialogResult res = System.Windows.Forms.MessageBox.Show("Ordner " + si.Name + " wirklich löschen?", "Leeren Ordner löschen", MessageBoxButtons.OKCancel, MessageBoxIcon.Exclamation);
 				if (res == DialogResult.OK)
 				{
 					Log("Lösche Ordner: " + si.Path);
 					Directory.Delete(si.Path);
 
 					RemoveStuffItemFromMyDisksTree( si );
 				}
 			}
 			catch (Exception e2)
 			{
 				LogError("Fehler beim Löschen: " + e2.Message);
 			}
 		}
 		/// <summary>
 		/// Alle markierten unterhalb eines Ordners löschen
 		/// </summary>
 		/// <param name="sender"></param>
 		/// <param name="e"></param>
 		void ContextDeleteAllMarkedFiles(object sender, EventArgs e)
 		{
 			StuffItem si = GetStuffItem(sender);
 			if (si == null || si.IsFile || si.IsOnForeignDisk)
 			{
 				return;
 			}
 
 			string meld = "";
 			if (si.Parent == null)
 			{
 				meld = "Alle markierten Dateien wirklich löschen?";
 			}
 			else
 			{
 				meld = "Alle markierten Dateien unterhalb " + si.Path + " wirklich löschen?";
 			}
 
 			DialogResult res = MessageBox.Show(meld, "Vorsicht, sie trennen sich von Material!", MessageBoxButtons.OKCancel, MessageBoxIcon.Warning);
 			if (res == DialogResult.OK)
 			{
 				DeleteAllMarkedFilesRecursive(si);
 			}
 		}
 
 		/// <summary>
 		/// Alle markierten unterhalb eines Ordners sperren und löschen
 		/// </summary>
 		/// <param name="sender"></param>
 		/// <param name="e"></param>
 		void ContextExcludeAndDeleteAllMarkedFiles(object sender, EventArgs e)
 		{
 			StuffItem si = GetStuffItem(sender);
 			if (si == null || si.IsFile ||si.IsOnForeignDisk)
 			{
 				return;
 			}
 
 			string meld = "";
 			if (si.Parent == null)
 			{
 				meld = "Alle markierten Dateien wirklich sperren und löschen?";
 			}
 			else
 			{
 				meld = "Alle markierten Dateien unterhalb " + si.Path + " wirklich sperren und löschen?";
 			}
 
 			if (MessageBox.Show(meld, "Vorsicht, sie trennen sich von Material!", 
 				MessageBoxButtons.OKCancel, MessageBoxIcon.Warning) == DialogResult.OK)
 			{
 				Recursive_ExcludeMarkers(si, true);
 				DeleteAllMarkedFilesRecursive(si);
 			}
 		}
 
 		/// <summary>
 		/// Hilfsfunktion um alle markierten Dateien rekrusiv zu löschen
 		/// </summary>
 		/// <param name="si"></param>
 		private void DeleteAllMarkedFilesRecursive(StuffItem si)
 		{
 			try
 			{
 				if ( si.IsFile )
 				{
 					if ( !si.Checked )
 					{
 						return;
 					}
 					// Datei löschen
 					Log( "Datei wird gelöscht: " + si.Path );
 					File.Delete( si.Path );
 					
 					// aus der StuffItem-Liste löschen
 					RemoveStuffItemFromMyDisksTree( si );
 				}
 				else
 				{
 					// Rückwärts durchlaufen wegen Löschen
 					for ( int j = si.ChildItems.Count - 1 ; j >= 0 ; j-- )
 					{
 						StuffItem csi = si.ChildItems[ j ];
 						DeleteAllMarkedFilesRecursive( csi );
 					}
 
 					// Leeres Verzeichnis löschen
 					if ( si.ChildItems.Count == 0 && si.Checked )
 					{
 						Log( "Leeres Verzeichnis wird gelöscht: " + si.Path );
 						Directory.Delete( si.Path );
 
 						RemoveStuffItemFromMyDisksTree( si );
 					}
 				}
 			}
 			catch (Exception e2)
 			{
 				LogError("Fehler beim Löschen: " + e2.Message);
 			}
 		}
 
 		private void RemoveStuffItemFromMyDisksTree( StuffItem si )
 		{
 			// Verweis vom Elternteil entfernen
 			si.Parent.ChildItems.Remove( si );
 
 			// Datei aus dem Tree entfernen
 			myDisksTree.FindSingleNode(si.Path).Remove();
 
 			// Einträge auch aus der MyDisksByHash-Liste entfernen
 			m_MyDisks.RemoveStuffItemFromHashes( si );
 
 			// Anzeige aktualisieren
 			UpdateTreeNodeIcon( si );
 		}
 
 		/// <summary>
 		/// Alle markierten unterhalb eines Ordners sperren
 		/// </summary>
 		/// <param name="sender"></param>
 		/// <param name="e"></param>
 		void ContextExcludeMarkers(object sender, EventArgs e)
 		{
 			StuffItem si = GetStuffItem(sender);
 			if (si == null || si.IsFile)
 			{
 				return;
 			}
 			Recursive_ExcludeMarkers(si, true);
 
 			// Markierungen entfernen, falls gewünscht
 			if (m_Config.IsRemoveMarks)
 			{
 				// Markierungen im aktuellen Tree entfernen
 				ContextRemoveMark(sender, e);
 			}
 		}
 
 		/// <summary>
 		/// Alle markierten unterhalb eines Ordners entsperren
 		/// </summary>
 		/// <param name="sender"></param>
 		/// <param name="e"></param>
 		void ContextIncludeMarkers(object sender, EventArgs e)
 		{
 			StuffItem si = GetStuffItem(sender);
 			if (si == null || si.IsFile)
 			{
 				return;
 			}
 			Recursive_ExcludeMarkers(si, false);
 
 			// Markierungen entfernen, falls gewünscht
 			if (m_Config.IsRemoveMarks)
 			{
 				// Markierungen im aktuellen Tree entfernen
 				ContextRemoveMark(sender, e);
 			}
 		}
 
 		/// <summary>
 		/// Hilfsfunktion um alle markierten Dateien rekursiv zu sperren
 		/// </summary>
 		/// <param name="si"></param>
 		/// <param name="exclude">true für Dateien sperren, false wenn die Dateien entsperren</param>
 		private void Recursive_ExcludeMarkers( StuffItem si, bool exclude )
 		{
 			try
 			{
 				if ( si.IsFile )
 				{
 					if ( si.Checked )
 					{
 						if ( exclude )
 						{
 							Log( "Datei gesperrt: " + si.Path );
 							si.Exclude();
 						}
 						else
 						{
 							Log( "Datei entsperrt: " + si.Path );
 							si.Include();
 						}
 
 						// TreeNodeIcon aktualisieren
 						UpdateTreeNodeIcon( si );
 					}
 				}
 				else
 				{
 					foreach ( StuffItem csi in si.ChildItems )
 					{
 						Recursive_ExcludeMarkers( csi, exclude );
 					}
 				}
 			}
 			catch ( Exception e2 )
 			{
 				LogError( "Fehler beim Sperren/Entsperren: " + e2.Message );
 			}
 		}
 
 		/// <summary>
 		/// Alle markierten Items in Kopierliste zusammenfassen und im Hintergrund kopieren
 		/// </summary>
 		/// <param name="sender"></param>
 		/// <param name="e"></param>
 		void ContextCopyAllClick(object sender, EventArgs e)
 		{
 			StuffItem trgt = GetStuffItem(sender);
 			if (trgt == null || trgt.IsFile)
 				return;
 			List<StuffItemPair> copylist = new List<StuffItemPair>();
 			ContextCopyAllClickAddChecked(copylist, otherDisksTree.Nodes[0]);
 
 			// Markierungen entfernen, falls gewünscht
 			// beim Kopieren schon jetzt, denn entfällt das manuelle Demarkieren
 			if (m_Config.IsRemoveMarks)
 			{
 				// Markierung immer im Tree "Fremde Platten" entfernen
 				ContextRemoveMark(otherDisksTree.Nodes[0].Tag, e);
 			}
 
 			foreach (StuffItemPair pair in copylist)
 			{
 				pair.Target = trgt;
 			}
 			// Kopieraktion starten
 			Program.RunBackgroundTask(this, "CopyFiles", copylist);
 		}
 
 		/// <summary>
 		/// Alle markierten Items in Kopierliste zusammenfassen und mit Pfad kopieren
 		/// </summary>
 		/// <param name="sender"></param>
 		/// <param name="e"></param>
 		void ContextCopyAllWithFoldersClick(object sender, EventArgs e)
 		{
 			StuffItem trgt = GetStuffItem(sender);
 			if (trgt == null || trgt.IsFile)
 				return;
 
 			List<StuffItemPair> copylist = new List<StuffItemPair>();
 			ContextCopyAllClickAddChecked(copylist, otherDisksTree.Nodes[0]);
 			foreach (StuffItemPair pair in copylist)
 			{
 				FileInfo fi = new FileInfo(pair.Source.Path);
 				string subpath = fi.DirectoryName.Replace(":", "").Replace("\\\\", "");
 				pair.Target = new StuffItem();
 				pair.Target.Path = trgt.Path + "\\" + subpath;
 			}
 
 			// Markierungen entfernen, falls gewünscht
 			// beim Kopieren schon jetzt, denn entfällt das manuelle Demarkieren
 			// beim Kopieren immer im Tree "Fremde Platten"
 			if (m_Config.IsRemoveMarks)
 			{
 				ContextRemoveMark(otherDisksTree.Nodes[0].Tag, e);
 			}
 
 			// Dateien kopieren
 			Program.RunBackgroundTask(this, "CopyFiles", copylist);
 		}
 
 		/// <summary>
 		/// Hilfsfunktion zum rekursiven Kopieren (ohne Erhalt der Hierarchie)
 		/// </summary>
 		/// <param name="copylist"></param>
 		/// <param name="node"></param>
 		void ContextCopyAllClickAddChecked(List<StuffItemPair> copylist, TreeNode node)
 		{
 			if (node.Checked)
 			{
 				StuffItem item = (StuffItem)node.Tag;
 				if (item != null && item.IsFile)
 				{
 					copylist.Add(new StuffItemPair());
 					copylist[copylist.Count - 1].Source = item;
 				}
 			}
 			foreach (TreeNode n in node.Nodes)
 			{
 				ContextCopyAllClickAddChecked(copylist, n);
 			}
 		}
 
 		/// <summary>
 		/// Aktualisiert das Icon eines bestimmten StuffItems in den TreeViews
 		/// </summary>
 		/// <param name="si">StuffItem, welches es zu aktualisieren gilt</param>
 		void UpdateTreeNodeIcon(StuffItem si)
 		{
 			TreeView currentTree = si.IsOnForeignDisk ? otherDisksTree : myDisksTree;
 			TreeNode tn = currentTree.FindSingleNode( si.Path );
 			if ( tn != null )
 			{
 				tn.ImageIndex = tn.SelectedImageIndex = ( int )si.Icon;
 			}
 
 			// lokale Dateien eines entfernten StuffItems ebenfalls anpassen
 			if ( si.IsOnForeignDisk )
 			{
 				foreach ( String localpath in si.GetLocalFiles )
 				{
 					tn = myDisksTree.FindSingleNode( localpath );
 					tn.ImageIndex = tn.SelectedImageIndex = ( int )( ( StuffItem )tn.Tag ).Icon;
 				}
 			}
 			else
 			{
 				// ggf. den anderen Tree auch anpassen (wg. Exludes)
 				foreach ( String remotepath in si.GetRemoteFiles )
 				{
 					tn = otherDisksTree.FindSingleNode( remotepath );
 					tn.ImageIndex = tn.SelectedImageIndex = ( int )( ( StuffItem )tn.Tag ).Icon;
 				}
 				// TODO: bei Excludes und aktiver Option zum Ausblenden von Items, dann muss das Ding ganz raus
 			}
 		}
 
 		#endregion
 
 		#region Markierungen setzen und entfernen (Kontextmenu)
 
 		/// <summary>
 		/// Alle Zweige ohne Markierung zuklappen
 		/// </summary>
 		/// <param name="sender"></param>
 		/// <param name="e"></param>
 		private void ContextCollapse(object sender, EventArgs e)
 		{
 			StuffItem si = GetStuffItem(sender);
 			if (si == null)
 			{
 				return;
 			}
 			if (si.IsOnForeignDisk)
 			{
 				CollapseOtherDisks();
 			}
 			else
 			{
 				CollapseMyDisks();
 			}
 		}
 
 		/// <summary>
 		/// Alle markieren, die zu saugen sind
 		/// </summary>
 		/// <param name="sender"></param>
 		/// <param name="e"></param>
 		private void ContextMarkMissingFiles(object sender, EventArgs e)
 		{
 			StuffItem si = GetStuffItem(sender);
 			if (si == null)
 			{
 				return;
 			}
 
 			Recursive_UpdateMark( si, true );
 			Recursive_MarkMissingFiles(si);
 		}
 
 		/// <summary>
 		/// Alle Dateien die ein Clone einer anderen sind markieren
 		/// </summary>
 		private void ContextMarkClones(object sender, EventArgs e)
 		{
 			StuffItem si = GetStuffItem(sender);
 			if (si == null)
 			{
 				return;
 			}
 
 			si.Checked = false;
 			foreach ( StuffItem clone in Program.MainWindow.m_MyDisks.GetItemClones( si ) )
 			{
 				TreeNode node = myDisksTree.FindSingleNode( clone.Path );
 				node.Checked = true;
 				node.Expand();
 			}
 		}
 
 		/// <summary>
 		/// Alle Dateien unterhalb eines Knotens markieren
 		/// </summary>
 		/// <param name="sender"></param>
 		/// <param name="e"></param>
 		private void ContextMark(object sender, EventArgs e)
 		{
 			StuffItem si = GetStuffItem(sender);
 			if (si == null)
 			{
 				return;
 			}
 
 			Recursive_UpdateMark( si, true );
 		}
 
 		/// <summary>
 		/// Alle Markierungen entfernen
 		/// </summary>
 		/// <param name="sender"></param>
 		/// <param name="e"></param>
 		private void ContextRemoveMark(object sender, EventArgs e)
 		{
 			StuffItem si = GetStuffItem(sender);
 			if (si == null)
 			{
 				return;
 			}
 
 			Recursive_UpdateMark( si, false );
 		}
 
 		/// <summary>
 		/// Alle markieren, die zu gelöscht werden können, weil doppelt
 		/// Das klappt nur auf dem Root-Node, dehalb nur da anbieten
 		/// </summary>
 		/// <param name="sender"></param>
 		/// <param name="e"></param>
 		private void ContextMarkDoubleEntries(object sender, EventArgs e)
 		{
 			StuffItem se = GetStuffItem(sender);
 			if (se == null)
 			{
 				return;
 			}
 			Recursive_UpdateMark( se, false );
 			Recursive_MarkDoubleEntries(se);
 		}
 
 
 		/// <summary>
 		/// Alle Dateien unterhalb eines Knotens mit einem manuellen Filterstring markieren
 		/// </summary>
 		/// <param name="sender"></param>
 		/// <param name="e"></param>
 		private void ContextMarkByFilter(object sender, EventArgs e)
 		{
 			// Ohne Startitem gehts nicht
 			StuffItem si = GetStuffItem(sender);
 			if (si == null)
 			{
 				return;
 			}
 
 			// Dialog aufbauen / abfragen
 			using (LanTool.FilterDialog filterDlg = new LanTool.FilterDialog())
 			{
 				filterDlg.Text = "Filtern unterhalb \"" + si.Path + "\"";
 
 				if (filterDlg.ShowDialog() == DialogResult.OK)
 				{
 					string filter = filterDlg.Expression;
 					// RegExp-Sonderzeichen per backslash quoten
 					string[] quote = new string[] { "\\", ".", "(", ")", "[", "]" };
 					foreach (string q in quote)
 						filter = filter.Replace(q, "\\" + q);
 
 					// Dos Wildcards durch RegExp ersetzen
 					filter = filter.Replace("*", ".*").Replace("?", ".");
 
 					// Losfiltern ab Item
 					Recursive_MarkByFilter(si, filter);
 				}
 			}
 		}
 
 		/// <summary>
 		/// Rekursion zum Markieren mit einem Filterstring
 		/// </summary>
 		/// <param name="si">aktuellles StuffItem</param>
 		/// <param name="filter">String-Filter</param>
 		private void Recursive_MarkByFilter(StuffItem si, string filter)
 		{
 			TreeView currenttree = si.IsOnForeignDisk ? otherDisksTree : myDisksTree;
 
 			foreach (StuffItem csi in si.ChildItems)
 			{
 				// wenn der Filter zutrifft, dann markieren
 				if (Regex.IsMatch(csi.Name, filter, RegexOptions.IgnoreCase))
 				{
 					currenttree.FindSingleNode(csi.Path).Checked = true;
 				}
 				// wenn Ordner, dann weiter rekursiv durch
 				if (!csi.IsFile)
 				{
 					Recursive_MarkByFilter(csi, filter);
 				}
 			}
 		}
 
 		/// <summary>
 		/// Rekursion zum Markieren fürs Saugen
 		/// </summary>
 		private void Recursive_MarkMissingFiles(StuffItem si)
 		{
 			TreeView currenttree = si.IsOnForeignDisk ? otherDisksTree : myDisksTree;
 	
 			// alle TreeNodes finden
 			foreach ( StuffItem csi in si.ChildItems )
 			{
 				TreeNode node = currenttree.FindSingleNode( csi.Path );
 				node.Checked = csi.IsNeeded;
 				if ( csi.IsNeeded )
 				{
 					node.Expand();
 				}
 
 				if ( !csi.IsFile )
 				{
 					Recursive_MarkMissingFiles( csi );
 				}
 			}
 		}
 
 		/// <summary>
 		/// Rekursiv alle untergeordneten Nodes de-/markieren
 		/// </summary>
 		private void Recursive_UpdateMark( StuffItem si, Boolean setMark )
 		{
 			TreeView currenttree = si.IsOnForeignDisk ? otherDisksTree : myDisksTree;
 
 			// alle TreeNodes finden
 			TreeNode node = currenttree.FindSingleNode( si.Path );
 			node.Checked = setMark;
 			if ( setMark )
 			{
 				node.Expand();
 			}
 
 			foreach ( StuffItem csi in si.ChildItems )
 			{
 				Recursive_UpdateMark( csi, setMark );
 			}
 		}
 
 		/// <summary>
 		/// Die nachfolgenden Duplikate markieren, d.h. das erste bleibt erhalten
 		/// Das kann nur klappen wenn auf RootNode begonnen wird und vorher alle Markierungen
 		/// zurückgesetzt werden!
 		/// </summary>
 		/// <param name="si"></param>
 		private void Recursive_MarkDoubleEntries(StuffItem si)
 		{
 			// nur bei den eigenen Platten
 			if (!si.IsOnForeignDisk)
 			{
 				// nur bei Dateien
 				if (si.IsFile)
 				{
 					if (!si.Checked && si.HasClones)
 					{
 						foreach ( StuffItem csi in Program.MainWindow.m_MyDisks.GetItemClones( si ) )
 						{
 							TreeNode node = myDisksTree.FindSingleNode( csi.Path );
 
 							node.Checked = true;
 							node.Expand();
 
 						}
 					}
 				}
 				else
 				{
 					foreach (StuffItem csi in si.ChildItems)
 					{
 						Recursive_MarkDoubleEntries(csi);
 					}
 				}
 			}
 		}
 
 		#endregion
 
 		#region Suchen
 
 		/// <summary>
 		/// Suche
 		/// </summary>
 		private bool ContextSearchRecursive(StuffItem si, string filter)
 		{
 			foreach (StuffItem se2 in si.ChildItems)
 			{
 				if (Regex.IsMatch(se2.Path, filter, RegexOptions.IgnoreCase) && !itemsAlreadyFound.Contains(se2.Path))
 				{
 					// Item zur Liste "bereits gefunden" hinzufügen
 					itemsAlreadyFound.Add(se2.Path);
 
 					// gesuchtes Item gefunden, dann 
 					TreeNode fn = FindNode(lastUsedView.Nodes[0].Nodes, se2.Path);
 					if (fn == null)
 					{
 						return false;
 					}
 					else
 					{
 						lastUsedView.SelectedNode = fn;
 						return true;
 					}
 				}
 				else
 				{
 					// keine Datei, dann die childs untersuchen
 					if (!se2.IsFile)
 						if (ContextSearchRecursive(se2, filter))
 							return true;
 				}
 			}
 
 			return false;
 		}
 		private TreeNode FindNode(TreeNodeCollection tncoll, String strText)
 		{
 			TreeNode tnFound = null;
 			foreach (TreeNode tnCurr in tncoll)
 			{
 				if (String.Equals(tnCurr.Name, strText, StringComparison.CurrentCultureIgnoreCase))
 				{
 					return tnCurr;
 				}
 				if (tnCurr.Nodes.Count > 0)
 					tnFound = FindNode(tnCurr.Nodes, strText);
 				if (tnFound != null)
 				{
 					return tnFound;
 				}
 			}
 			return null;
 		}
 
 		/// <summary>
 		/// Im Suchfeld wurde eine Taste betätigt
 		/// </summary>
 		/// <param name="sender"></param>
 		/// <param name="e"></param>
 		private void searchField_KeyUp(object sender, KeyEventArgs e)
 		{
 			if (e.KeyCode == Keys.Return)
 			{
 				// wenn es um eine neue Suche handelt, dann die bereits gefunden Liste zurücksetzen
 				if (!String.Equals(lastSearchString, searchField.Text, StringComparison.CurrentCultureIgnoreCase))
 				{
 					itemsAlreadyFound.Clear();
 
 					lastSearchString = searchField.Text;
 				}
 
 				String filter = searchField.Text;
 
 				// wenn kein Suchtext angegeben wurde, dann wird auch nichts gesucht
 				if (!String.IsNullOrEmpty(filter))
 				{
 
 					// RegExp-Sonderzeichen per backslash quoten
 					string[] quote = new string[] { "\\", ".", "(", ")", "[", "]" };
 					foreach (string q in quote)
 						filter = filter.Replace(q, "\\" + q);
 
 					// Dos Wildcards durch RegExp ersetzen
 					filter = filter.Replace("*", ".*").Replace("?", ".");
 
 					StuffItem si = (StuffItem)lastUsedView.Nodes[0].Tag;
 
 					// Suche beim aktuellen Item starten
 					if (!ContextSearchRecursive(si, filter))
 					{
 						Status("Keine (weiteren) Treffer.");
 						// Bereits gefunden Liste zurücksetzen
 						itemsAlreadyFound.Clear();
 					}
 
 					// damit das ganze auch sichtbar wird, den TreeView fokusieren
 					lastUsedView.Focus();
 				}
 				else
 				{
 					searchField.Focus();
 				}
 			}
 		}
 
 		/// <summary>
 		/// Suchen-Button im Menü
 		/// </summary>
 		/// <param name="sender"></param>
 		/// <param name="e"></param>
 		private void suchenToolStripMenuItem_Click(object sender, EventArgs e)
 		{
 			// gleiche Funktion wie Enter im Suchfeld
 			searchField_KeyUp(sender, new KeyEventArgs(Keys.Return));
 		}
 
 		#endregion
 
 		/// <summary>
 		/// Neuen Ordner anlegen
 		/// </summary>
 		/// <param name="sender"></param>
 		/// <param name="e"></param>
 		private void ContextNewFolder(object sender, EventArgs e)
 		{
 			// Ohne Startitem gehts nicht
 			StuffItem si = GetStuffItem(sender);
 			if (si == null)
 			{
 				return;
 			}
 
 			// Dialog aufbauen / abfragen
 			using (NewFolderDialog folderDlg = new NewFolderDialog())
 			{
 				folderDlg.Text = "Neuen Ordner anlegen unterhalb \"" + si.Path + "\":";
 				if (folderDlg.ShowDialog() == DialogResult.OK)
 				{
 					string folder = folderDlg.NewFolderName;
 					// Sonderzeichen durch _ ersetzen
 					foreach ( char q in Path.GetInvalidPathChars() )
 					{
 						folder = folder.Replace( q, '_' );
 					}
 					// Losfiltern ab Item
 					Directory.CreateDirectory(Path.Combine(si.Path, folder));
 
 					si.AddOrGetChildItemByPath( Path.Combine( si.Path, folder ) );
 					
 					UpdateTreeRecursive( myDisksTree.Nodes[si.Path], si, false);
 				}
 			}
 		}
 
 		#region Speichern und laden einer Fileliste als Ersatz für dem MyDisk-Filesystem Scan
 	  
 		/// <summary>
 		/// Verzeichnisse exportieren (werden durch realen Scan aufgebaut)
 		/// </summary>
 		/// <param name="sender"></param>
 		/// <param name="e"></param>
 		private void verzeichnisFürMeinePlattenExportierenToolStripMenuItem_Click(object sender, EventArgs e)
 		{
 			using (SaveFileDialog fd = new SaveFileDialog())
 			{
 				fd.Filter = "LanTool-Verzeichnis-Export (*.files)|*.files|Textdateien (*.txt)|*.txt";
 				fd.DefaultExt = "*.files";
 				fd.FileName = "MeinePlatten.files";
 				fd.InitialDirectory = MainForm.basePath;
 				fd.CheckFileExists = false;
 				fd.CheckPathExists = true;
 				fd.AutoUpgradeEnabled = true;
 				if (fd.ShowDialog(this).Equals(DialogResult.OK))
 				{
                     Log(String.Format("Offline-Datei {0} wurde gespeichert.", fd.FileName));
 					m_MyDisks.SaveOfflineCacheToFile(fd.FileName);
 				}
 			}
 		}
 
 		/// <summary>
 		/// Einlesen einer Cache-Datei für den Offline-Betrieb
 		/// </summary>
 		/// <param name="sender"></param>
 		/// <param name="e"></param>
 		private void verzeichnisFürMeinePlattenImportierenToolStripMenuItem_Click(object sender, EventArgs e)
 		{
 			using (OpenFileDialog fd = new OpenFileDialog())
 			{
 				fd.Filter = "LanTool-Verzeichnis-Export (*.files)|*.files|Textdateien (*.txt)|*.txt";
 				fd.DefaultExt = "*.files";
 				fd.FileName = "MeinePlatten.files";
 				fd.InitialDirectory = MainForm.basePath;
 				fd.CheckFileExists = true;
 				fd.CheckPathExists = true;
 				fd.Multiselect = false;
 				fd.AutoUpgradeEnabled = true;
 				if (fd.ShowDialog(this) == DialogResult.OK)
 				{
 					m_MyDisks.LoadOfflineCacheFromFile(fd.FileName);
 					m_MyDisks.IsOnline = false;
 
                     Log(String.Format("Offline-Datei {0} wurde eingelesen.", fd.FileName));
 
 					UpdateTrees();
 				}
 			}
 		}
 
 		private void offlineCacheLöschenToolStripMenuItem_Click(object sender, EventArgs e)
 		{
 			m_MyDisks.ResetOfflineCaches();
 			m_MyDisks.IsOnline = true;
 			
 			UpdateTrees();
 		}
 
 		#endregion
 
 		/// <summary>
 		/// Speichern welcher TreeView zuletzt aufgerufen wurde
 		/// </summary>
 		/// <param name="sender"></param>
 		/// <param name="e"></param>
 		private void DisksTree_Enter(object sender, EventArgs e)
 		{
 			lastUsedView = (TreeView)sender;
 		}
 
 		/// <summary>
 		/// Ausführen einer Datei durch Doppelklick
 		/// </summary>
 		private void tree_MouseDoubleClick(object sender, MouseEventArgs e)
 		{
 			try
 			{
 				// nur bei Linksklick reagieren
 				if (e.Button.Equals(MouseButtons.Left))
 				{
 					Point clickPoint = new Point(e.X, e.Y);
 
 					// Objekt unter der Maus holen
 					TreeNode clickNode = ((TreeView)sender).GetNodeAt(clickPoint);
 					// ins leere geklickt -> nichts tun
 					if ( clickNode == null || clickNode.Tag == null )
 					{
 						return;
 					}
 
 					StuffItem tn = (StuffItem)clickNode.Tag;
 					// kein StuffItem dran oder keine Datei
 					if ( tn == null || !tn.IsFile )
 					{
 						return;
 					}
 					
 					// Datei ausführen
 					Status("Starte Datei: " + tn.Path);
 					Process.Start(tn.Path);
 				}
 			}
 			catch (Exception e2)
 			{
 				LogError("Fehler beim Ausführen: " + e2.Message);
 			}
 		}
 
 		/// <summary>
 		/// Hotkeys behandeln
 		/// </summary>
 		/// <param name="sender"></param>
 		/// <param name="e"></param>
 		private void MainForm_KeyUp(object sender, KeyEventArgs e)
 		{
 			// ins Suchfeld springen bei Strg+F
 			if (e.KeyCode == Keys.F && Control.ModifierKeys == Keys.Control)
 			{
 				searchField.Focus();
 			}
 			// gleiche Funktion wie Enter im Suchfeld
 			else if (e.KeyCode == Keys.F3)
 			{ 
 				searchField_KeyUp(sender, new KeyEventArgs(Keys.Return));
 			}
 		}
 		
 		private void MainForm_FormClosing(object sender, FormClosingEventArgs e)
 		{
 			// Caches auf die Platte schreiben
 			m_Cache.Dispose();
 		}
 
 		/// <summary>
 		/// Nach Auswahl eines Elementes den Pfad zum Element in der Textbox anzeigen
 		/// </summary>
 		private void myDisksTree_AfterSelect(object sender, TreeViewEventArgs e)
 		{
 			StuffItem selectedStuffItem = (StuffItem)myDisksTree.SelectedNode.Tag;
 			if (selectedStuffItem.IsFile)
 			{
 				myDisksPath.Text = Path.GetDirectoryName(selectedStuffItem.Path);
 			}
 			else
 			{
 				myDisksPath.Text = selectedStuffItem.Path;
 			}
 		}
 
 		/// <summary>
 		/// Nach Auswahl eines Elementes den Pfad zum Element in der Textbox anzeigen
 		/// </summary>
 		private void otherDisksTree_AfterSelect(object sender, TreeViewEventArgs e)
 		{
 			StuffItem selectedStuffItem = (StuffItem)otherDisksTree.SelectedNode.Tag;
 			if (selectedStuffItem.IsFile)
 			{
 				otherDisksPath.Text = Path.GetDirectoryName(selectedStuffItem.Path);
 			}
 			else
 			{ 
 				otherDisksPath.Text = selectedStuffItem.Path;
 			}
 		}
 
 		#region Pfad-Felder über den TreeViews
 
 		private void DisksPath_OpenPath(object sender, MouseEventArgs e)
 		{
 			String path = ((TextBox)sender).Text;
 
 			// Links -> Pfad im Explorer öffnen
 			if (e.Button == MouseButtons.Left)
 			{
 				try
 				{
 					// Nach oben suchen bis ein Text entsteht, der als Verzeichnis existiert
 					while ( !Directory.Exists( path ) && path.Length > 0 )
 					{
 						path = path.Substring( 0, path.LastIndexOf( @"\" ) );
 					}
 
 					// im Explorer öffnen
 					if ( !Directory.Exists( path ) )
 					{
 						return;
 					}
 
 					Status( "Öffne Verzeichnis: " + path );
 					Process.Start( path );
 				}
 				catch { }
 			}
 			// Rechtsklick -> in die Zwischenablage
 			if (e.Button == MouseButtons.Right)
 			{
 				Clipboard.SetDataObject(path, true);
 			}
 		}
 
 		private void DisksPath_KeyUp(object sender, KeyEventArgs e)
 		{
 			if (e.KeyCode == Keys.Enter)
 				DisksPath_OpenPath(sender, new MouseEventArgs(MouseButtons.Left, 2, 0, 0, 0));
 		}
 
 		#endregion
 
 		#region Info-Menü
 
 		private void lanToolForumToolStripMenuItem_Click(object sender, EventArgs e)
 		{
 			Process.Start("http://www.rw-net.de/bbl/index.php?page=Board&boardID=21");
 		}
 
 		private void lanToolTippsTricksToolStripMenuItem_Click(object sender, EventArgs e)
 		{
 			Process.Start("http://www.rw-net.de/LanTool_Tipps.txt");
 		}
 
 		private void lanToolChangeLogToolStripMenuItem_Click(object sender, EventArgs e)
 		{
 			Process.Start("http://www.rw-net.de/LanTool_ChangeLog.txt");
 		}
 
 		private void überToolStripMenuItem_Click(object sender, EventArgs e)
 		{
 			new AboutBox().ShowDialog();
 		}
 
 		private void fTPMitDemLanToolNetDriveToolStripMenuItem_Click(object sender, EventArgs e)
 		{
 			try
 			{
 				if (File.Exists("NetDrive-Setup.exe"))
 					Process.Start("NetDrive-Setup.exe");
 				else
 					Process.Start("http://www.netdrive.net");
 			}
 			catch
 			{ }
 		}
 
 		#endregion
 
 		/// <summary>
 		/// Aktualisierung der beiden TreeViews starten
 		/// </summary>
 		private void StartUpdate()
 		{
 			// Auto Scan anwerfen
 			if (m_Config.IsAutoScanMyDisks)
 			{
 				m_MyDisks.UpdateChildsBackground();
 			}
 			if (m_Config.IsAutoScanOtherDisks)
 			{
 				Program.MainWindow.m_OtherDisks.UpdateChildsBackground();
 			}
 
 			Program.MainWindow.UpdateTrees();
 		}
 	}
 }