lantool

StuffItem.cs (15062B)

---

 using System;
 using System.Collections.Generic;
 using System.IO;
 
 namespace LanTool.Classes
 {
 	internal class StuffItemSorter : System.Collections.IComparer
 	{
 		public int Compare( object xx, object yy )
 		{
 			StuffItem x = ( StuffItem )( ( System.Windows.Forms.TreeNode )xx ).Tag;
 			StuffItem y = ( StuffItem )( ( System.Windows.Forms.TreeNode )yy ).Tag;
 			string xa = ( x == null ) ? "0" : ( x.IsFile ? "2" + x.Path : "1" + x.Path );
 			string ya = ( y == null ) ? "0" : ( y.IsFile ? "2" + y.Path : "1" + y.Path );
 			return String.Compare( xa, ya );
 		}
 	}
 
 	/// <summary>
 	/// Ein Ding des Begehrs, sei es auf der eigenen oder der fremden Platte
 	/// </summary>
 	internal class StuffItem
 	{
 		#region Parameter eines StuffItems
 
 		/// <summary>
 		/// Übergeordnetes StuffItem
 		/// </summary>
 		public StuffItem Parent = null;
 
 		private string _name = String.Empty;
 		/// <summary>
 		/// Name des StuffItems
 		/// z.B. Dateiname ohne Pfad oder Name des Verzeichnisses 
 		/// </summary>
 		public string Name
 		{
 			get
 			{
 				// Field ist noch nicht gefüllt, dann Name aus dem Dateiname oder dem Verzeichnisname ermitteln
 				if ( String.IsNullOrEmpty( _name ) )
 				{
 					if ( IsFile )
 					{
 						_name = System.IO.Path.GetFileName( Path );
 					}
 					else
 					{
 						_name = Path.Substring( Path.LastIndexOf( "\\" ) + 1 );
 					}
 				}
 
 				return _name;
 			}
 			private set
 			{
 				_name = value;
 			}
 
 		}
 		
 		/// <summary>
 		/// Kompletter Pfad zum StuffItems
 		/// </summary>
 		public string Path = String.Empty;
 
 		/// <summary>
 		/// Liste aller direkt untergeordneten StuffItems
 		/// </summary>
 		public List<StuffItem> ChildItems = new List<StuffItem>();
 		
 		/// <summary>
 		/// MD5-Hashwert des StuffItems
 		/// </summary>
 		public string Hash = "";
 		
 		/// <summary>
 		/// Dateigröße
 		/// </summary>
 		public long Size;
 		
 		/// <summary>
 		/// Dateigröße in lesbarer Ausgabe
 		/// </summary>
 		public string ReadableSize
 		{
 			get
 			{
 				if ( this.Size > 1024 * 1024 )
 					return ( ( ( double )( this.Size / 104857 ) ) / 10 ).ToString() + " MB";
 				else
 					return ( ( ( double )( this.Size / 102 ) ) / 10 ).ToString() + " KB";
 			}
 		}
 
 		/// <summary>
 		/// Dateigröße in Byte-Ausgabe
 		/// </summary>
 		public string LongSize
 		{
 			get
 			{
 				// Zahlenformat: mit 1000er-Punkten ohne Nachkommastellen
 				return String.Format( "{0:N0} Bytes", this.Size );
 			}
 		}
 
 		private bool _checked = false;
 		/// <summary>
 		/// Dateien, die markiert sind aber nicht sichtbar, werden als nicht markiert gehandhabt
 		/// </summary>		
 		public bool Checked
 		{
 			get
 			{
 				return _checked && IsVisible;
 			}
 			set
 			{
 				_checked = value;
 			}
 		}
 
 		private bool updateCheck = true;
 
 		private bool _isOnline = true;
 		/// <summary>
 		/// Online und Offline wird grundsätzlich für den ganzen Zweig darunter gesetzt
 		/// </summary>
 		public bool IsOnline
 		{
 			get
 			{
 				return _isOnline;
 			}
 			set
 			{
 				_isOnline = value;
 				foreach ( StuffItem si in ChildItems )
 					si.IsOnline = value;
 			}
 		}
 
 		/// <summary>
 		/// True wenn es sich um eine Datei handelt
 		/// </summary>
 		public bool IsFile = false;
 
 		/// <summary>
 		/// Legt das Icon für die Dateien/Ordner fest
 		/// </summary>
 		public TreeNodeImage Icon
 		{
 			get
 			{
 				if ( this.HasReadError )
 				{
 					if ( this.IsFile )
 					{
 						return TreeNodeImage.FileError;
 					}
 					else
 					{
 						return TreeNodeImage.BrokenFolder;
 					}
 				}
 				else if ( !this.IsFile )
 				{
 					return TreeNodeImage.Folder;
 				}
 				else if ( this.IsIgnored )
 				{
 					return TreeNodeImage.FileIngored;
 				}
 				else if ( this.IsExcluded )
 				{
 					return TreeNodeImage.FileExcluded;
 				}
 				else if ( this.HasClones )
 				{
 					return TreeNodeImage.FileRed;
 				}
 				else if ( this.IsNeeded )
 				{
 					return TreeNodeImage.FileSaugMich;
 				}
 				else if ( this.IsOnForeignDisk )
 				{
 					return TreeNodeImage.FileHabSchon;
 				}
 				else
 				{
 					return TreeNodeImage.FileWhite;
 				}
 			}
 		}
 
 		/// <summary>
 		/// Liefert den Anzeigetext für TreeNode fest
 		/// </summary>
 		public string Text
 		{
 			get
 			{
 				String dispName = Name.Substring( Name.LastIndexOf( "\\" ) + 1 );
 				if ( Parent == Program.MainWindow.m_MyDisks || Parent == Program.MainWindow.m_OtherDisks )
 				{
 					dispName = Name;
 				}
 
 				if ( IsFile && !HasReadError )
 				{
 					return String.Format( "{0} ({1})", dispName, ReadableSize );
 				}
 				else
 				{
 					return dispName;
 				}
 			}
 		}
 
 		/// <summary>
 		/// Gibt den ToolTip-Text für die Datei zurück
 		/// </summary>
 		public string ToolTip
 		{
 			get
 			{
 				if ( !this.IsFile )
 				{
 					return String.Empty;
 				}
 
 				string temp;
 
 				// Standardausgaben
 				temp = "Pfad: " + this.Path + Environment.NewLine;
 
 				// die nachfolgenden Sachen nur anzeigen, wenn keine Lesefehler vorliegen
 				if ( this.HasReadError )
 				{
 					temp += "Datei hat Lesefehler!";
 
 					return temp;
 				}
 
 				temp += "Größe: " + this.LongSize + Environment.NewLine +
 					"Hash: " + this.Hash + Environment.NewLine;
 
 				// bei schon auf vorhandenen Dateien auf den fremden Platten, die lokalen
 				// Dateien mit anzeigen
 				if ( IsOnForeignDisk && !IsNeeded && !IsExcluded )
 				{
 					temp += Environment.NewLine + "Meine Platten: " + Environment.NewLine +
 						String.Join( Environment.NewLine, this.GetLocalFiles.ToArray() );
 				}
 
 				// bei Dubletten auf den eigenen Platten, diese anzeigen
 				if ( !IsOnForeignDisk && IsFile )
 				{
 					List<StuffItem> clones = Program.MainWindow.m_MyDisks.GetItemClones( this );
 					if ( clones.Count > 0 )
 					{
 						temp += Environment.NewLine + "Dubletten: ";
 						foreach ( StuffItem csi in clones )
 						{
 							temp += Environment.NewLine + csi.Path;
 						}
 					}
 				}
 
 				return temp;
 			}
 		}
 
 		/// <summary>
 		/// Gibt an, ob die Datei im Tree sichtbar ist
 		/// betrifft nur tatsächliche Dateien auf fremden Platten
 		/// abhängig vom Status der Datei und den eingestellten Optionen
 		/// </summary>
 		public bool IsVisible
 		{
 			get
 			{
 				// wenn keine Datei oder nicht auf fremden Platten - immer sichtbar
 				if ( !IsFile || !IsOnForeignDisk )
 				{
 					return true;
 				}
 				else
 				{
 					// Dateien die gesperrt sind ausblenden falls Option aktiv
 					if ( IsExcluded && Program.MainWindow.m_Config.IsHideExcludedFiles )
 					{
 						return false;
 					}
 					// Dateien die nicht gebraucht werden ausblenden falls Option aktiv
 					if ( !IsExcluded && !IsNeeded && Program.MainWindow.m_Config.IsHideExistingFiles )
 					{
 						return false;
 					}
 				}
 
 				return true;
 			}
 		}
 
 		/// <summary>
 		/// True wenn die Datei ausgeschlossen ist
 		/// </summary>
 		public bool IsExcluded
 		{
 			get
 			{
 				return IsFile && Program.MainWindow.m_Cache.ExcludeCache.Contains( Program.MainWindow.m_Config.MD5FileSize + " " + this.Hash );
 			}
 		}
 
 		/// <summary>
 		/// True wenn die Datei-Dubletten ignoriert werden
 		/// </summary>
 		public bool IsIgnored
 		{
 			get
 			{
 				return IsFile && !IsOnForeignDisk && HasClones && Program.MainWindow.m_Cache.IgnoreCache.Contains( Program.MainWindow.m_Config.MD5FileSize + " " + this.Hash );
 			}
 		}
 
 		/// <summary>
 		/// Gibt an, ob beim Lesen des Verzeichnisses/der Datei ein Fehler aufgetreten ist
 		/// </summary>
 		public bool HasReadError = false;
 
 		/// <summary>
 		/// Gibt ab, ob sich die Datei auf einer fremden Platte befindet
 		/// </summary>
 		public bool IsOnForeignDisk = false;
 
 		/// <summary>
 		/// true, wenn die Datei noch nicht auf den eigenen Platten vorhanden ist und nicht
 		/// ausgeschlossen ist
 		/// </summary>
 		public bool IsNeeded
 		{
 			get
 			{
 				return IsFile && IsOnForeignDisk && !IsExcluded &&
 					( Program.MainWindow.m_MyDisks.GetRecursiveItemCount( this ) == 0 );
 			}
 		}
 
 		/// <summary>
 		/// Gibt alle lokalen Dateien eines StuffItems zurück
 		/// </summary>
 		public List<String> GetLocalFiles
 		{
 			get
 			{
 				List<String> localFiles = new List<String>();
 				if ( Program.MainWindow.m_MyDisks.GetRecursiveItemCount( this ) > 0 )
 				{
 					foreach ( StuffItem lsi in Program.MainWindow.m_MyDisks.GetItemsRecursive( this ) )
 					{
 						localFiles.Add( lsi.Path );
 					}
 				}
 				return localFiles;
 			}
 		}
 
 		/// <summary>
 		/// Gibt alle Dateien auf fremden Platten eines StuffItems zurück
 		/// </summary>
 		public List<String> GetRemoteFiles
 		{
 			get
 			{
 				List<String> remoteFiles = new List<String>();
 				if ( Program.MainWindow.m_OtherDisks.GetRecursiveItemCount( this ) > 0 )
 				{
 					foreach ( StuffItem lsi in Program.MainWindow.m_OtherDisks.GetItemsRecursive( this ) )
 					{
 						remoteFiles.Add( lsi.Path );
 					}
 				}
 				return remoteFiles;
 			}
 		}
 
 		public bool HasClones
 		{
 			get
 			{
 				return IsFile && !IsOnForeignDisk && Program.MainWindow.m_MyDisks.GetRecursiveItemCount( this ) > 1;
 			}
 		}
 
 		/// <summary>
 		/// Speicher für Offline-Kopie der Directory-Anfragen
 		/// </summary>
 		virtual public Dictionary<string, List<string>> OfflineDirs
 		{
 			get
 			{
 				return Parent.OfflineDirs;
 			}
 		}
 
 		/// <summary>
 		/// Speicher für Offline-Kopie der Files-Anfragen
 		/// </summary>
 		virtual public Dictionary<string, List<string>> OfflineFiles
 		{
 			get
 			{
 				return Parent.OfflineFiles;
 			}
 		}
 
 		/// <summary>
 		/// Ein StuffItem für einen (Datei-)Pfad hinzufügen, falls
 		/// für diesen Pfad noch keines existiert
 		/// </summary>
 		/// <param name="path">Pfad</param>
 		/// <returns>Das alte oder neue Item</returns>
 		public StuffItem AddOrGetChildItemByPath( string path )
 		{
 			// Altes Item suchen (nach Pfadnamen)
 			foreach ( StuffItem si in this.ChildItems )
 			{
 				if ( si.Path.Equals( path ) )
 				{
 					si.updateCheck = true;
 					return si;
 				}
 			}
 
 			// Neues Item einhängen, wenn das alte nicht exisitert
 			StuffItem new_si = new StuffItem();
 			new_si.IsOnForeignDisk = this.IsOnForeignDisk;
 			new_si.Name = path;
 			new_si.Path = path;
 			new_si.Parent = this;
 			new_si.IsOnline = IsOnline;
 			new_si.updateCheck = true;
 			this.ChildItems.Add( new_si );
 			return new_si;
 		}
 
 		#endregion
 
 		#region Aktionen am Item
 
 		/// <summary>
 		/// Datei sperren
 		/// </summary>
 		public void Exclude()
 		{
 			Program.MainWindow.m_Cache.ExcludeCache.Add( Program.MainWindow.m_Config.MD5FileSize + " " + this.Hash );
 		}
 
 		/// <summary>
 		/// Gesperrte Datei wieder reinnehmen
 		/// </summary>
 		public void Include()
 		{
 			Program.MainWindow.m_Cache.ExcludeCache.Remove( Program.MainWindow.m_Config.MD5FileSize + " " + this.Hash );
 		}
 
 		/// <summary>
 		/// Datei ignorieren
 		/// </summary>
 		public void Ignore()
 		{
 			Program.MainWindow.m_Cache.IgnoreCache.Add( Program.MainWindow.m_Config.MD5FileSize + " " + this.Hash );
 		}
 
 		/// <summary>
 		/// Ignorierte Datei wieder reinnehmen
 		/// </summary>
 		public void UnIgnore()
 		{
 			Program.MainWindow.m_Cache.IgnoreCache.Remove( Program.MainWindow.m_Config.MD5FileSize + " " + this.Hash );
 		}
 
 		#endregion
 
 		#region Platten scannen
 
 		/// <summary>
 		/// ChildItems aktualisieren (background task)
 		/// </summary>
 		public void UpdateChildsBackground()
 		{
 			Program.RunBackgroundTask( this, "UpdateChilds", null );
 		}
 
 		/// <summary>
 		/// ChildItem aktualisieren und MainWindow neu aufbauen (Background Task)
 		/// </summary>
 		public void UpdateChilds( object state )
 		{
 			// Statt der RootItems alle deren Kinder scannen
 			if ( this == Program.MainWindow.m_MyDisks || this == Program.MainWindow.m_OtherDisks )
 			{
 				foreach ( StuffItem si in this.ChildItems.ToArray() )
 				{
 					si.ScanChilds();
 				}
 			}
 			else
 			{
 				this.ScanChilds();
 			}
 
 			// Die Caches des jeweiligen Trees aktualisieren, in der das Item aktualisiert wurde
 			Program.MainWindow.m_MyDisks.CreateStuffItemTreeHash();
 			Program.MainWindow.m_OtherDisks.CreateStuffItemTreeHash();
 
 			// Baum neu zeichnen
 			Program.MainWindow.UpdateTrees();
 		}
 
 		/// <summary>
 		/// ChildItems eines Items von der Platte einlesen (rekursiv) und Hash-Werte ermitteln
 		/// </summary>
 		private void ScanChilds()
 		{
 			try
 			{
 				// Alle Childs markieren, dass sie nicht aktualisiert wurden
 				foreach ( StuffItem si in this.ChildItems )
 				{
 					si.updateCheck = false;
 				}
 
 				// Verzeichnisse lesen, die nicht "excluded" durch Extension sind
 				string[] dirs = GetDirectories;
 				foreach ( string dirname in dirs )
 				{
 					if ( !Program.MainWindow.m_Config.IsDirExludedByExtension( dirname ) )
 					{
 						StuffItem si = this.AddOrGetChildItemByPath( dirname ); 
 						si.Path = dirname;
 						si.IsOnForeignDisk = this.IsOnForeignDisk;
 						si.ScanChilds();
 					}
 				}
 
 				// Files lesen, die nicht excluded sind. 
 				// Bei "restricted" extensions werden nur diese gelesen, "excluded" zählt dann nicht
 				string[] files = GetFiles;
 				foreach ( string filename in files )
 				{
 					if ( !Program.MainWindow.m_Config.IsFileExludedByExtension( filename ) )
 					{
 						StuffItem si = AddOrGetChildItemByPath( filename );
 						si.Path = filename;
 						si.IsFile = true;
 						si.IsOnForeignDisk = IsOnForeignDisk;
 						si.Hash = Program.MainWindow.m_Cache.GetHashCodeFromFileHeader( filename );
 						// wenn kein Hash ermittelt wurde, kann die Datei nicht gelesen werden
 						if ( String.IsNullOrEmpty( si.Hash ) )
 						{
 							si.HasReadError = true;
 						}
 						else
 						{
 							si.Size = Convert.ToInt64( si.Hash.Substring( 33 ), 16 );
 						}
 					}
 				}
 
 				// Nun alle Items wegwerfen, die kein Update hatten
 				for ( int i = ChildItems.Count - 1; i >= 0; i-- )
 				{
 					if ( !ChildItems[ i ].updateCheck )
 					{
 						ChildItems.RemoveAt( i );
 					}
 				}
 				this.HasReadError = false;
 			}
 			catch ( Exception e )
 			{
 				Program.MainWindow.LogError( "Fehler beim Einlesen: " + e.Message );
 				this.HasReadError = true;
 			}
 		}
 
 		/// <summary>
 		/// Verzeichnisse eines Pfades aus dem SimDirs oder physikalisch lesen.
 		/// </summary>
 		/// <returns></returns>
 		private string[] GetDirectories
 		{
 			get
 			{
 				if ( IsOnline )
 				{
 					Program.MainWindow.Status( "Lese Verzeichnis (online): " + this.Path + " " );
 					OfflineDirs[ Path ] = new List<string>( Directory.GetDirectories( Path ) );
 				}
 				else
 				{
 					Program.MainWindow.Status( "Lese Verzeichnis (offline): " + this.Path + " " );
 				}
 				if ( OfflineDirs.ContainsKey( Path ) )
 				{
 					return OfflineDirs[ Path ].ToArray();
 				}
 				else
 				{
 					return new string[] { };
 				}
 			}
 		}
 
 		/// <summary>
 		/// Files eines Pfades aus dem SimDirs oder physikalisch lesen.
 		/// </summary>
 		/// <returns></returns>
 		private string[] GetFiles
 		{
 			get
 			{
 				// bei Online-Dateien direkt von der Platte esen
 				if ( IsOnline )
 				{
 					OfflineFiles[ Path ] = new List<string>( Directory.GetFiles( this.Path ) );
 				}
 
 				// Bei Offline-Dateien die Hashcaches prüfen
 				if ( OfflineFiles.ContainsKey( Path ) )
 				{
 					return OfflineFiles[ Path ].ToArray();
 				}
 				else
 				{
 					return new string[] { };
 				}
 			}
 		}
 
 		#endregion
 	}
 }