Changeset 915


Ignore:
Timestamp:
4/28/2009 2:38:18 PM (6 years ago)
Author:
lowjoel
Message:

-Don't nest publicly accessible classes in classes.
-Camelcasing for abbreviations
-Abstract class constructors should be protected

Location:
branches/eraser6
Files:
17 edited

Legend:

Unmodified
Added
Removed
  • branches/eraser6/Eraser/Program.cs

    r911 r915  
    794794                else if (IsParam(param, "recycled", "r")) 
    795795                { 
    796                     targets.Add(new Task.RecycleBin()); 
     796                    targets.Add(new RecycleBinTarget()); 
    797797                } 
    798798                else if (IsParam(param, "unused", "u")) 
     
    803803 
    804804                    //Create the UnusedSpace target for inclusion into the task. 
    805                     Task.UnusedSpace target = new Task.UnusedSpace(); 
     805                    UnusedSpaceTarget target = new UnusedSpaceTarget(); 
    806806 
    807807                    //Determine if cluster tips should be erased. 
     
    825825 
    826826                    //Create the base target 
    827                     Task.Folder target = new Task.Folder(); 
     827                    FolderTarget target = new FolderTarget(); 
    828828 
    829829                    //Parse the subparameters. 
     
    858858                { 
    859859                    //It's just a file! 
    860                     Task.File target = new Task.File(); 
     860                    FileTarget target = new FileTarget(); 
    861861                    target.Path = Path.GetFullPath(param); 
    862862                    targets.Add(target); 
     
    891891            /// The list of targets which was specified on the command line. 
    892892            /// </summary> 
    893             public List<Task.ErasureTarget> Targets 
     893            public List<ErasureTarget> Targets 
    894894            { 
    895895                get 
    896896                { 
    897                     return new List<Task.ErasureTarget>(targets.ToArray()); 
     897                    return new List<ErasureTarget>(targets.ToArray()); 
    898898                } 
    899899            } 
     
    901901            private Guid erasureMethod; 
    902902            private Schedule schedule = Schedule.RunNow; 
    903             private List<Task.ErasureTarget> targets = new List<Task.ErasureTarget>(); 
     903            private List<ErasureTarget> targets = new List<ErasureTarget>(); 
    904904        } 
    905905        #endregion 
     
    10861086                ErasureMethodManager.Default : 
    10871087                ErasureMethodManager.GetInstance(taskArgs.ErasureMethod); 
    1088             foreach (Task.ErasureTarget target in taskArgs.Targets) 
     1088            foreach (ErasureTarget target in taskArgs.Targets) 
    10891089            { 
    10901090                target.Method = method; 
  • branches/eraser6/Eraser/SchedulerPanel.cs

    r909 r915  
    270270                !(e.Task.Schedule is RecurringSchedule) && highestLevel < LogLevel.Warning) 
    271271            { 
    272                 Program.eraserClient.DeleteTask(e.Task.ID); 
     272                Program.eraserClient.DeleteTask(e.Task.Id); 
    273273            } 
    274274 
     
    478478                Task task = (Task)item.Tag; 
    479479                if (!task.Executing) 
    480                     Program.eraserClient.DeleteTask(task.ID); 
     480                    Program.eraserClient.DeleteTask(task.Id); 
    481481            } 
    482482        } 
  • branches/eraser6/Eraser/SettingsPanel.cs

    r909 r915  
    7474            item.Checked = instance.Plugin != null || 
    7575                (Manager.ManagerLibrary.Instance.Settings.PluginApprovals.ContainsKey( 
    76                     instance.AssemblyInfo.GUID) && Manager.ManagerLibrary.Instance. 
    77                     Settings.PluginApprovals[instance.AssemblyInfo.GUID] 
     76                    instance.AssemblyInfo.Guid) && Manager.ManagerLibrary.Instance. 
     77                    Settings.PluginApprovals[instance.AssemblyInfo.Guid] 
    7878                ); 
    7979 
     
    363363            { 
    364364                PluginInstance plugin = (PluginInstance)item.Tag; 
    365                 Guid guid = plugin.AssemblyInfo.GUID; 
     365                Guid guid = plugin.AssemblyInfo.Guid; 
    366366                if (!pluginApprovals.ContainsKey(guid)) 
    367367                { 
  • branches/eraser6/Eraser/TaskDataSelectionForm.cs

    r909 r915  
    9595        /// <returns>An Eraser.Manager.Task.Data or Eraser.Manager.Task.UnusedSpace object 
    9696        /// or any of its inherited classes, depending on the task selected</returns> 
    97         public Task.ErasureTarget Target 
     97        public ErasureTarget Target 
    9898        { 
    9999            get 
    100100            { 
    101                 Task.ErasureTarget result = null; 
     101                ErasureTarget result = null; 
    102102                if (file.Checked) 
    103103                { 
    104                     Manager.Task.File fileTask = new Task.File(); 
     104                    FileTarget fileTask = new FileTarget(); 
    105105                    result = fileTask; 
    106106 
     
    109109                else if (folder.Checked) 
    110110                { 
    111                     Manager.Task.Folder folderTask = new Task.Folder(); 
     111                    FolderTarget folderTask = new FolderTarget(); 
    112112                    result = folderTask; 
    113113 
     
    119119                else if (unused.Checked) 
    120120                { 
    121                     Task.UnusedSpace unusedSpaceTask = new Task.UnusedSpace(); 
     121                    UnusedSpaceTarget unusedSpaceTask = new UnusedSpaceTarget(); 
    122122                    result = unusedSpaceTask; 
    123123 
     
    127127                else 
    128128                { 
    129                     Task.RecycleBin recycleBinTask = new Task.RecycleBin(); 
     129                    RecycleBinTarget recycleBinTask = new RecycleBinTarget(); 
    130130                    result = recycleBinTask; 
    131131                } 
     
    147147 
    148148                //Then the data to be erased. 
    149                 if (value is Task.File) 
     149                if (value is FileTarget) 
    150150                { 
    151151                    file.Checked = true; 
    152                     filePath.Text = ((Task.File)value).Path; 
    153                 } 
    154                 else if (value is Task.Folder) 
     152                    filePath.Text = ((FileTarget)value).Path; 
     153                } 
     154                else if (value is FolderTarget) 
    155155                { 
    156156                    folder.Checked = true; 
    157                     Manager.Task.Folder folderTask = (Task.Folder)value; 
     157                    FolderTarget folderTask = (FolderTarget)value; 
    158158 
    159159                    folderPath.Text = folderTask.Path; 
     
    162162                    folderDelete.Checked = folderTask.DeleteIfEmpty; 
    163163                } 
    164                 else if (value is Task.UnusedSpace) 
     164                else if (value is UnusedSpaceTarget) 
    165165                { 
    166166                    unused.Checked = true; 
    167                     Task.UnusedSpace unusedSpaceTask = (Task.UnusedSpace)value; 
     167                    UnusedSpaceTarget unusedSpaceTask = (UnusedSpaceTarget)value; 
    168168                    foreach (object item in unusedDisk.Items) 
    169169                        if (((DriveItem)item).Drive == unusedSpaceTask.Drive) 
     
    171171                    unusedClusterTips.Checked = unusedSpaceTask.EraseClusterTips; 
    172172                } 
    173                 else if (value is Task.RecycleBin) 
     173                else if (value is RecycleBinTarget) 
    174174                { 
    175175                    recycleBin.Checked = true; 
  • branches/eraser6/Eraser/TaskPropertiesForm.cs

    r905 r915  
    132132 
    133133            //The data 
    134             foreach (Task.ErasureTarget target in task.Targets) 
     134            foreach (ErasureTarget target in task.Targets) 
    135135            { 
    136136                ListViewItem item = data.Items.Add(target.UIText); 
     
    203203                if (form.ShowDialog() == DialogResult.OK) 
    204204                { 
    205                     Task.ErasureTarget target = form.Target; 
     205                    ErasureTarget target = form.Target; 
    206206                    ListViewItem item = data.Items.Add(target.UIText); 
    207207                    item.SubItems.Add(target.MethodDefined ? target.Method.Name : S._("(default)")); 
     
    228228                if (form.ShowDialog() == DialogResult.OK) 
    229229                { 
    230                     Task.ErasureTarget target = form.Target; 
     230                    ErasureTarget target = form.Target; 
    231231                    task.Targets[item.Index] = target; 
    232232                    item.Text = target.UIText; 
     
    263263            foreach (ListViewItem obj in data.SelectedItems) 
    264264            { 
    265                 task.Targets.Remove((Task.ErasureTarget)obj.Tag); 
     265                task.Targets.Remove((ErasureTarget)obj.Tag); 
    266266                data.Items.Remove(obj); 
    267267            } 
  • branches/eraser6/Manager/DirectExecutor.cs

    r913 r915  
    6666                if (unusedIds.Count != 0) 
    6767                { 
    68                     task.ID = unusedIds[0]; 
     68                    task.Id = unusedIds[0]; 
    6969                    unusedIds.RemoveAt(0); 
    7070                } 
    7171                else 
    72                     task.ID = ++nextId; 
     72                    task.Id = ++nextId; 
    7373            } 
    7474 
     
    7878            //Add the task to the set of tasks 
    7979            lock (tasksLock) 
    80                 tasks.Add(task.ID, task); 
     80                tasks.Add(task.Id, task); 
    8181 
    8282            //Call all the event handlers who registered to be notified of tasks 
     
    111111 
    112112                for (int i = 0; i != scheduledTasks.Count; ) 
    113                     if (scheduledTasks.Values[i].ID == taskId) 
     113                    if (scheduledTasks.Values[i].Id == taskId) 
    114114                        scheduledTasks.RemoveAt(i); 
    115115                    else 
     
    128128            { 
    129129                //Replace the task in the global set 
    130                 if (!tasks.ContainsKey(task.ID)) 
     130                if (!tasks.ContainsKey(task.Id)) 
    131131                    return; 
    132132 
    133                 tasks[task.ID] = task; 
     133                tasks[task.Id] = task; 
    134134 
    135135                //Then replace the task if it is in the queue 
    136136                for (int i = 0; i != scheduledTasks.Count; ++i) 
    137                     if (scheduledTasks.Values[i].ID == task.ID) 
     137                    if (scheduledTasks.Values[i].Id == task.Id) 
    138138                    { 
    139139                        scheduledTasks.RemoveAt(i); 
     
    313313                        //Run the task 
    314314                        TaskProgressManager progress = new TaskProgressManager(currentTask); 
    315                         foreach (Task.ErasureTarget target in task.Targets) 
     315                        foreach (ErasureTarget target in task.Targets) 
    316316                            try 
    317317                            { 
    318318                                progress.Event.CurrentTarget = target; 
    319319                                ++progress.Event.CurrentTargetIndex; 
    320                                 if (target is Task.UnusedSpace) 
    321                                     EraseUnusedSpace(task, (Task.UnusedSpace)target, progress); 
    322                                 else if (target is Task.FilesystemObject) 
    323                                     EraseFilesystemObject(task, (Task.FilesystemObject)target, progress); 
     320                                if (target is UnusedSpaceTarget) 
     321                                    EraseUnusedSpace(task, (UnusedSpaceTarget)target, progress); 
     322                                else if (target is FileSystemObjectTarget) 
     323                                    EraseFilesystemObject(task, (FileSystemObjectTarget)target, progress); 
    324324                                else 
    325325                                    throw new ArgumentException(S._("Unknown erasure target.")); 
     
    501501            public TaskProgressManager(Task task) 
    502502            { 
    503                 foreach (Task.ErasureTarget target in task.Targets) 
     503                foreach (ErasureTarget target in task.Targets) 
    504504                    Total += target.TotalData; 
    505505 
     
    534534        /// <param name="target">The target of the unused space erase.</param> 
    535535        /// <param name="progress">The progress manager object managing the progress of the task</param> 
    536         private void EraseUnusedSpace(Task task, Task.UnusedSpace target, TaskProgressManager progress) 
     536        private void EraseUnusedSpace(Task task, UnusedSpaceTarget target, TaskProgressManager progress) 
    537537        { 
    538538            //Check for sufficient privileges to run the unused space erasure. 
     
    702702            string currentFilePath, int totalFiles); 
    703703 
    704         private static void EraseClusterTips(Task task, Task.UnusedSpace target, 
     704        private static void EraseClusterTips(Task task, UnusedSpaceTarget target, 
    705705            ErasureMethod method, ClusterTipsEraseProgress callback) 
    706706        { 
     
    868868        /// <param name="target">The target of the erasure.</param> 
    869869        /// <param name="progress">The progress manager for the current task.</param> 
    870         private void EraseFilesystemObject(Task task, Task.FilesystemObject target, 
     870        private void EraseFilesystemObject(Task task, FileSystemObjectTarget target, 
    871871            TaskProgressManager progress) 
    872872        { 
     
    981981 
    982982            //If the user requested a folder removal, do it. 
    983             if (target is Task.Folder) 
     983            if (target is FolderTarget) 
    984984            { 
    985985                progress.Event.CurrentItemName = S._("Removing folders..."); 
    986986                task.OnProgressChanged(progress.Event); 
    987987 
    988                 Task.Folder fldr = (Task.Folder)target; 
     988                FolderTarget fldr = (FolderTarget)target; 
    989989                if (fldr.DeleteIfEmpty) 
    990990                { 
     
    995995 
    996996            //If the user was erasing the recycle bin, clear the bin. 
    997             if (target is Task.RecycleBin) 
     997            if (target is RecycleBinTarget) 
    998998            { 
    999999                progress.Event.CurrentItemName = S._("Emptying recycle bin..."); 
  • branches/eraser6/Manager/EntropySource.cs

    r905 r915  
    145145        /// Retrieves the instance of the EntropySource with the given GUID. 
    146146        /// </summary> 
    147         /// <param name="guid">The GUID of the EntropySource.</param> 
     147        /// <param name="value">The GUID of the EntropySource.</param> 
    148148        /// <returns>The EntropySource instance.</returns> 
    149         public static EntropySource GetInstance(Guid guid) 
     149        public static EntropySource GetInstance(Guid value) 
    150150        { 
    151151            try 
    152152            { 
    153153                lock (ManagerLibrary.Instance.EntropySourceManager.sources) 
    154                     return ManagerLibrary.Instance.EntropySourceManager.sources[guid]; 
     154                    return ManagerLibrary.Instance.EntropySourceManager.sources[value]; 
    155155            } 
    156156            catch (KeyNotFoundException) 
    157157            { 
    158158                throw new FatalException(S._("EntropySource GUID not found: {0}", 
    159                     guid.ToString())); 
     159                    value.ToString())); 
    160160            } 
    161161        } 
     
    197197        /// The delegate prototype of Entropy Source Registered event  
    198198        /// </summary> 
    199         /// <param name="guid"></param> 
    200         public delegate void OnEntropySourceActivatedEventHandler(Guid guid); 
     199        /// <param name="value"></param> 
     200        public delegate void OnEntropySourceActivatedEventHandler(Guid value); 
    201201 
    202202        /// <summary> 
  • branches/eraser6/Manager/Logger.cs

    r905 r915  
    9595        /// </summary> 
    9696        /// <param name="e"></param> 
    97         public delegate void LogEventFunction(LogEntry e); 
     97        public delegate void LogEventFunction(LogEntry entry); 
    9898 
    9999        /// <summary> 
  • branches/eraser6/Manager/Manager.cs

    r905 r915  
    9393        /// Global instance of the Settings manager. 
    9494        /// </summary> 
    95         public SettingsManager SettingsManager; 
     95        public SettingsManager SettingsManager { get; set; } 
    9696 
    9797        /// <summary> 
  • branches/eraser6/Manager/Method.cs

    r905 r915  
    103103        /// instance, this function may be called across different threads. 
    104104        /// </summary> 
    105         /// <param name="strm">The stream which needs to be erased.</param> 
     105        /// <param name="stream">The stream which needs to be erased.</param> 
    106106        /// <param name="erasureLength">The length of the stream to erase. If all 
    107107        /// data in the stream should be overwritten, then pass in the maximum 
     
    109109        /// <param name="prng">The PRNG source for random data.</param> 
    110110        /// <param name="callback">The progress callback function.</param> 
    111         public abstract void Erase(Stream strm, long erasureLength, Prng prng, 
     111        public abstract void Erase(Stream stream, long erasureLength, Prng prng, 
    112112            ProgressFunction callback); 
    113113 
     
    254254        /// <param name="prng">The PRNG source for random data.</param> 
    255255        /// <param name="callback">The progress callback function.</param> 
    256         public virtual void EraseUnusedSpace(Stream strm, Prng prng, ProgressFunction callback) 
    257         { 
    258             Erase(strm, long.MaxValue, prng, callback); 
     256        public virtual void EraseUnusedSpace(Stream stream, Prng prng, ProgressFunction callback) 
     257        { 
     258            Erase(stream, long.MaxValue, prng, callback); 
    259259        } 
    260260    } 
     
    538538        /// The delegate prototype of the Method Registered event. 
    539539        /// </summary> 
    540         /// <param name="method">The GUID of the method being registered.</param> 
    541         public delegate void MethodRegisteredFunction(Guid guid); 
     540        /// <param name="value">The GUID of the method being registered.</param> 
     541        public delegate void MethodRegisteredFunction(Guid value); 
    542542 
    543543        /// <summary> 
     
    549549        /// The delegate prototype of the Method Unregistered event. 
    550550        /// </summary> 
    551         /// <param name="method">The GUID of the method being registered.</param> 
    552         public delegate void MethodUnregisteredFunction(Guid guid); 
     551        /// <param name="value">The GUID of the method being registered.</param> 
     552        public delegate void MethodUnregisteredFunction(Guid value); 
    553553 
    554554        /// <summary> 
  • branches/eraser6/Manager/PRNG.cs

    r905 r915  
    170170        /// Retrieves the instance of the PRNG with the given GUID. 
    171171        /// </summary> 
    172         /// <param name="guid">The GUID of the PRNG.</param> 
     172        /// <param name="value">The GUID of the PRNG.</param> 
    173173        /// <returns>The PRNG instance.</returns> 
    174         public static Prng GetInstance(Guid guid) 
     174        public static Prng GetInstance(Guid value) 
    175175        { 
    176176            try 
    177177            { 
    178178                lock (ManagerLibrary.Instance.PRNGManager.prngs) 
    179                     return ManagerLibrary.Instance.PRNGManager.prngs[guid]; 
     179                    return ManagerLibrary.Instance.PRNGManager.prngs[value]; 
    180180            } 
    181181            catch (KeyNotFoundException) 
    182182            { 
    183                 throw new FatalException(S._("PRNG not found: {0}", guid.ToString())); 
     183                throw new FatalException(S._("PRNG not found: {0}", value.ToString())); 
    184184            } 
    185185        } 
  • branches/eraser6/Manager/Plugins.cs

    r905 r915  
    195195                !MsCorEEAPI.VerifyStrongName(filePath) || 
    196196                instance.AssemblyAuthenticode == null) && 
    197                 !approvals.ContainsKey(instance.AssemblyInfo.GUID)) 
     197                !approvals.ContainsKey(instance.AssemblyInfo.Guid)) 
    198198            { 
    199199                return; 
     
    228228 
    229229            //See if the user disabled this plugin (users cannot disable Core plugins) 
    230             if (approvals.ContainsKey(instance.AssemblyInfo.GUID) && 
    231                 !approvals[instance.AssemblyInfo.GUID] && !instance.IsCore) 
     230            if (approvals.ContainsKey(instance.AssemblyInfo.Guid) && 
     231                !approvals[instance.AssemblyInfo.Guid] && !instance.IsCore) 
    232232            { 
    233233                return; 
     
    304304                foreach (CustomAttributeData attr in attributes) 
    305305                    if (attr.Constructor.DeclaringType == typeof(GuidAttribute)) 
    306                         assemblyInfo.GUID = new Guid((string)attr.ConstructorArguments[0].Value); 
     306                        assemblyInfo.Guid = new Guid((string)attr.ConstructorArguments[0].Value); 
    307307                    else if (attr.Constructor.DeclaringType == typeof(AssemblyCompanyAttribute)) 
    308308                        assemblyInfo.Author = (string)attr.ConstructorArguments[0].Value; 
     
    383383        /// The GUID of the assembly. 
    384384        /// </summary> 
    385         public Guid GUID { get; set; } 
     385        public Guid Guid { get; set; } 
    386386 
    387387        /// <summary> 
  • branches/eraser6/Manager/Schedule.cs

    r905 r915  
    172172 
    173173        #region Object serialization 
    174         public RecurringSchedule(SerializationInfo info, StreamingContext context) 
     174        protected RecurringSchedule(SerializationInfo info, StreamingContext context) 
    175175        { 
    176176            type = (ScheduleUnit)info.GetValue("Type", typeof(ScheduleUnit)); 
  • branches/eraser6/Manager/Strings.en.resx

    r901 r915  
    292292    <value>The ScheduleUnit of the schedule does not use the WeeklyScheduly value, this field would contain garbage</value> 
    293293  </data> 
     294  <data name="An invalid type was found when loading the task schedule" xml:space="preserve"> 
     295    <value>An invalid type was found when loading the task schedule</value> 
     296  </data> 
    294297  <data name="Unused disk space ({0})" xml:space="preserve"> 
    295298    <value>Unused disk space ({0})</value> 
     
    301304    <value>Recycle Bin</value> 
    302305  </data> 
    303   <data name="An invalid type was found when loading the task schedule" xml:space="preserve"> 
    304     <value>An invalid type was found when loading the task schedule</value> 
    305   </data> 
    306306</root> 
  • branches/eraser6/Manager/Strings.nl.resx

    r901 r915  
    292292    <value>(Untranslated)</value> 
    293293  </data> 
     294  <data name="An invalid type was found when loading the task schedule" xml:space="preserve"> 
     295    <value>(Untranslated)</value> 
     296  </data> 
    294297  <data name="Unused disk space ({0})" xml:space="preserve"> 
    295298    <value>(Untranslated)</value> 
     
    301304    <value>(Untranslated)</value> 
    302305  </data> 
    303   <data name="An invalid type was found when loading the task schedule" xml:space="preserve"> 
    304     <value>(Untranslated)</value> 
    305   </data> 
    306306</root> 
  • branches/eraser6/Manager/Strings.resx

    r901 r915  
    292292    <value>The ScheduleUnit of the schedule does not use the WeeklyScheduly value, this field would contain garbage</value> 
    293293  </data> 
     294  <data name="An invalid type was found when loading the task schedule" xml:space="preserve"> 
     295    <value>An invalid type was found when loading the task schedule</value> 
     296  </data> 
    294297  <data name="Unused disk space ({0})" xml:space="preserve"> 
    295298    <value>Unused disk space ({0})</value> 
     
    301304    <value>Recycle Bin</value> 
    302305  </data> 
    303   <data name="An invalid type was found when loading the task schedule" xml:space="preserve"> 
    304     <value>An invalid type was found when loading the task schedule</value> 
    305   </data> 
    306306</root> 
  • branches/eraser6/Manager/Task.cs

    r905 r915  
    3737    public class Task : ISerializable 
    3838    { 
    39         /// <summary> 
    40         /// Represents a generic target of erasure 
    41         /// </summary> 
    42         [Serializable] 
    43         public abstract class ErasureTarget : ISerializable 
    44         { 
    45             #region Serialization code 
    46             public ErasureTarget(SerializationInfo info, StreamingContext context) 
    47             { 
    48                 Guid methodGuid = (Guid)info.GetValue("Method", typeof(Guid)); 
    49                 if (methodGuid == Guid.Empty) 
    50                     method = ErasureMethodManager.Default; 
    51                 else 
    52                     method = ErasureMethodManager.GetInstance(methodGuid); 
    53             } 
    54  
    55             public virtual void GetObjectData(SerializationInfo info, 
    56                 StreamingContext context) 
    57             { 
    58                 info.AddValue("Method", method.Guid); 
    59             } 
    60             #endregion 
    61  
    62             /// <summary> 
    63             /// Constructor. 
    64             /// </summary> 
    65             public ErasureTarget() 
    66             { 
    67             } 
    68  
    69             /// <summary> 
    70             /// The method used for erasing the file. If the variable is equal to 
    71             /// ErasureMethodManager.Default then the default is queried for the 
    72             /// task type. 
    73             /// </summary> 
    74             public abstract ErasureMethod Method 
    75             { 
    76                 get; 
    77                 set; 
    78             } 
    79  
    80             /// <summary> 
    81             /// Checks whether a method has been selected for this target. This is 
    82             /// because the Method property will return non-default erasure methods 
    83             /// only. 
    84             /// </summary> 
    85             public bool MethodDefined 
    86             { 
    87                 get 
    88                 { 
    89                     return method != ErasureMethodManager.Default; 
    90                 } 
    91             } 
    92  
    93             /// <summary> 
    94             /// The task which owns this target. 
    95             /// </summary> 
    96             public Task Task 
    97             { 
    98                 get 
    99                 { 
    100                     return task; 
    101                 } 
    102                 internal set 
    103                 { 
    104                     task = value; 
    105                 } 
    106             } 
    107  
    108             /// <summary> 
    109             /// Retrieves the text to display representing this task. 
    110             /// </summary> 
    111             public abstract string UIText 
    112             { 
    113                 get; 
    114             } 
    115  
    116             /// <summary> 
    117             /// Retrieves the amount of data that needs to be written in order to 
    118             /// complete the erasure. 
    119             /// </summary> 
    120             public abstract long TotalData 
    121             { 
    122                 get; 
    123             } 
    124  
    125             /// <summary> 
    126             /// Erasure method to use for the target. 
    127             /// </summary> 
    128             protected ErasureMethod method; 
    129  
    130             /// <summary> 
    131             /// The task object owning this target. 
    132             /// </summary> 
    133             private Task task; 
    134         } 
    135  
    136         /// <summary> 
    137         /// Class representing a tangible object (file/folder) to be erased. 
    138         /// </summary> 
    139         [Serializable] 
    140         public abstract class FilesystemObject : ErasureTarget 
    141         { 
    142             #region Serialization code 
    143             public FilesystemObject(SerializationInfo info, StreamingContext context) 
    144                 : base(info, context) 
    145             { 
    146                 path = (string)info.GetValue("Path", typeof(string)); 
    147             } 
    148  
    149             override public void GetObjectData(SerializationInfo info, 
    150                 StreamingContext context) 
    151             { 
    152                 base.GetObjectData(info, context); 
    153                 info.AddValue("Path", path); 
    154             } 
    155             #endregion 
    156  
    157             /// <summary> 
    158             /// Constructor. 
    159             /// </summary> 
    160             public FilesystemObject() 
    161             { 
    162             } 
    163  
    164             /// <summary> 
    165             /// Retrieves the list of files/folders to erase as a list. 
    166             /// </summary> 
    167             /// <param name="totalSize">Returns the total size in bytes of the 
    168             /// items.</param> 
    169             /// <returns>A list containing the paths to all the files to be erased.</returns> 
    170             internal abstract List<string> GetPaths(out long totalSize); 
    171  
    172             /// <summary> 
    173             /// Adds ADSes of the given file to the list. 
    174             /// </summary> 
    175             /// <param name="list">The list to add the ADS paths to.</param> 
    176             /// <param name="file">The file to look for ADSes</param> 
    177             protected void GetPathADSes(ref List<string> list, ref long totalSize, string file) 
    178             { 
    179                 try 
    180                 { 
    181                     //Get the ADS names 
    182                     List<string> adses = Util.File.GetADSes(new FileInfo(file)); 
    183  
    184                     //Then prepend the path. 
    185                     foreach (string adsName in adses) 
    186                     { 
    187                         string adsPath = file + ':' + adsName; 
    188                         list.Add(adsPath); 
    189                         Util.StreamInfo info = new Util.StreamInfo(adsPath); 
    190                         totalSize += info.Length; 
    191                     } 
    192                 } 
    193                 catch (UnauthorizedAccessException e) 
    194                 { 
    195                     //The system cannot read the file, assume no ADSes for lack of 
    196                     //more information. 
    197                     Task.Log.Add(new LogEntry(e.Message, LogLevel.Error)); 
    198                 } 
    199             } 
    200  
    201             /// <summary> 
    202             /// The path to the file or folder referred to by this object. 
    203             /// </summary> 
    204             public string Path 
    205             { 
    206                 get { return path; } 
    207                 set { path = value; } 
    208             } 
    209  
    210             public override ErasureMethod Method 
    211             { 
    212                 get 
    213                 { 
    214                     if (method != ErasureMethodManager.Default) 
    215                         return method; 
    216                     return ErasureMethodManager.GetInstance( 
    217                         ManagerLibrary.Instance.Settings.DefaultFileErasureMethod); 
    218                 } 
    219                 set 
    220                 { 
    221                     method = value; 
    222                 } 
    223             } 
    224  
    225             public override string UIText 
    226             { 
    227                 get { return Path; } 
    228             } 
    229  
    230             public override long TotalData 
    231             { 
    232                 get 
    233                 { 
    234                     long totalSize = 0; 
    235                     List<string> paths = GetPaths(out totalSize); 
    236                     return Method.CalculateEraseDataSize(paths, totalSize); 
    237                 } 
    238             } 
    239  
    240             private string path; 
    241         } 
    242  
    243         /// <summary> 
    244         /// Class representing a unused space erase. 
    245         /// </summary> 
    246         [Serializable] 
    247         public class UnusedSpace : ErasureTarget 
    248         { 
    249             #region Serialization code 
    250             UnusedSpace(SerializationInfo info, StreamingContext context) 
    251                 : base(info, context) 
    252             { 
    253                 Drive = (string)info.GetValue("Drive", typeof(string)); 
    254                 EraseClusterTips = (bool)info.GetValue("EraseClusterTips", typeof(bool)); 
    255             } 
    256  
    257             public override void GetObjectData(SerializationInfo info, 
    258                 StreamingContext context) 
    259             { 
    260                 base.GetObjectData(info, context); 
    261                 info.AddValue("Drive", Drive); 
    262                 info.AddValue("EraseClusterTips", EraseClusterTips); 
    263             } 
    264             #endregion 
    265  
    266             /// <summary> 
    267             /// Constructor. 
    268             /// </summary> 
    269             public UnusedSpace() 
    270             { 
    271             } 
    272  
    273             public override ErasureMethod Method 
    274             { 
    275                 get 
    276                 { 
    277                     if (method != ErasureMethodManager.Default) 
    278                         return method; 
    279                     return ErasureMethodManager.GetInstance( 
    280                         ManagerLibrary.Instance.Settings.DefaultUnusedSpaceErasureMethod); 
    281                 } 
    282                 set 
    283                 { 
    284                     method = value; 
    285                 } 
    286             } 
    287  
    288             public override string UIText 
    289             { 
    290                 get { return S._("Unused disk space ({0})", Drive); } 
    291             } 
    292  
    293             public override long TotalData 
    294             { 
    295                 get 
    296                 { 
    297                     VolumeInfo info = VolumeInfo.FromMountpoint(Drive); 
    298                     return Method.CalculateEraseDataSize(null, info.AvailableFreeSpace); 
    299                 } 
    300             } 
    301  
    302             /// <summary> 
    303             /// The drive to erase 
    304             /// </summary> 
    305             public string Drive { get; set; } 
    306  
    307             /// <summary> 
    308             /// Whether cluster tips should be erased. 
    309             /// </summary> 
    310             public bool EraseClusterTips { get; set; } 
    311         } 
    312  
    313         /// <summary> 
    314         /// Class representing a file to be erased. 
    315         /// </summary> 
    316         [Serializable] 
    317         public class File : FilesystemObject 
    318         { 
    319             #region Serialization code 
    320             protected File(SerializationInfo info, StreamingContext context) 
    321                 : base(info, context) 
    322             { 
    323             } 
    324             #endregion 
    325  
    326             /// <summary> 
    327             /// Constructor. 
    328             /// </summary> 
    329             public File() 
    330             { 
    331             } 
    332  
    333             internal override List<string> GetPaths(out long totalSize) 
    334             { 
    335                 List<string> result = new List<string>(); 
    336                 totalSize = 0; 
    337                 GetPathADSes(ref result, ref totalSize, Path); 
    338  
    339                 totalSize += new FileInfo(Path).Length; 
    340                 result.Add(Path); 
    341                 return result; 
    342             } 
    343         } 
    344  
    345         /// <summary> 
    346         /// Represents a folder and its files which are to be erased. 
    347         /// </summary> 
    348         [Serializable] 
    349         public class Folder : FilesystemObject 
    350         { 
    351             #region Serialization code 
    352             protected Folder(SerializationInfo info, StreamingContext context) 
    353                 : base(info, context) 
    354             { 
    355                 includeMask = (string)info.GetValue("IncludeMask", typeof(string)); 
    356                 excludeMask = (string)info.GetValue("ExcludeMask", typeof(string)); 
    357                 deleteIfEmpty = (bool)info.GetValue("DeleteIfEmpty", typeof(bool)); 
    358             } 
    359  
    360             public override void GetObjectData(SerializationInfo info, 
    361                 StreamingContext context) 
    362             { 
    363                 base.GetObjectData(info, context); 
    364                 info.AddValue("IncludeMask", includeMask); 
    365                 info.AddValue("ExcludeMask", excludeMask); 
    366                 info.AddValue("DeleteIfEmpty", deleteIfEmpty); 
    367             } 
    368             #endregion 
    369  
    370             /// <summary> 
    371             /// Constructor. 
    372             /// </summary> 
    373             public Folder() 
    374             { 
    375             } 
    376  
    377             internal override List<string> GetPaths(out long totalSize) 
    378             { 
    379                 //Get a list to hold all the resulting paths. 
    380                 List<string> result = new List<string>(); 
    381  
    382                 //Open the root of the search, including every file matching the pattern 
    383                 DirectoryInfo dir = new DirectoryInfo(Path); 
    384  
    385                 //List recursively all the files which match the include pattern. 
    386                 string includeMask = IncludeMask; 
    387                 if (includeMask.Length == 0) 
    388                     includeMask = "*"; 
    389                 FileInfo[] files = GetFiles(dir, includeMask); 
    390  
    391                 //Then exclude each file and finalize the list and total file size 
    392                 totalSize = 0; 
    393                 if (ExcludeMask.Length != 0) 
    394                 { 
    395                     string regex = Regex.Escape(ExcludeMask).Replace("\\*", ".*"). 
    396                         Replace("\\?", "."); 
    397                     Regex excludePattern = new Regex(regex, RegexOptions.IgnoreCase); 
    398                     foreach (FileInfo file in files) 
    399                         if ((file.Attributes & FileAttributes.ReparsePoint) == 0 && 
    400                             excludePattern.Matches(file.FullName).Count == 0) 
    401                         { 
    402                             totalSize += file.Length; 
    403                             GetPathADSes(ref result, ref totalSize, file.FullName); 
    404                             result.Add(file.FullName); 
    405                         } 
    406                 } 
    407                 else 
    408                     foreach (FileInfo file in files) 
    409                     { 
    410                         if ((file.Attributes & FileAttributes.ReparsePoint) != 0) 
    411                             continue; 
    412  
    413                         totalSize += file.Length; 
    414                         GetPathADSes(ref result, ref totalSize, file.FullName); 
    415                         result.Add(file.FullName); 
    416                     } 
    417  
    418                 //Return the filtered list. 
    419                 return result; 
    420             } 
    421  
    422             /// <summary> 
    423             /// Gets all files in the provided directory. 
    424             /// </summary> 
    425             /// <param name="info">The directory to look files in.</param> 
    426             /// <param name="includeMask">The include mask all files must match.</param> 
    427             /// <returns>A list of files found in the directory.</returns> 
    428             private FileInfo[] GetFiles(DirectoryInfo info, string includeMask) 
    429             { 
    430                 List<FileInfo> result = new List<FileInfo>(); 
    431                 foreach (DirectoryInfo dir in info.GetDirectories()) 
    432                     try 
    433                     { 
    434                         result.AddRange(GetFiles(dir, includeMask)); 
    435                     } 
    436                     catch (Exception e) 
    437                     { 
    438                         //Ignore, but log. 
    439                         Task.log.Add(new LogEntry(S._("Could not erase {0} because {1}", 
    440                             dir.FullName, e.Message), LogLevel.Error)); 
    441                     } 
    442  
    443                 result.AddRange(info.GetFiles(includeMask, SearchOption.TopDirectoryOnly)); 
    444                 return result.ToArray(); 
    445             } 
    446  
    447             /// <summary> 
    448             /// A wildcard expression stating the condition for the set of files to include. 
    449             /// The include mask is applied before the exclude mask is applied. If this value 
    450             /// is empty, all files and folders within the folder specified is included. 
    451             /// </summary> 
    452             public string IncludeMask 
    453             { 
    454                 get { return includeMask; } 
    455                 set { includeMask = value; } 
    456             } 
    457  
    458             /// <summary> 
    459             /// A wildcard expression stating the condition for removing files from the set 
    460             /// of included files. If this value is omitted, all files and folders extracted 
    461             /// by the inclusion mask is erased. 
    462             /// </summary> 
    463             public string ExcludeMask 
    464             { 
    465                 get { return excludeMask; } 
    466                 set { excludeMask = value; } 
    467             } 
    468  
    469             /// <summary> 
    470             /// Determines if Eraser should delete the folder after the erase process. 
    471             /// </summary> 
    472             public bool DeleteIfEmpty 
    473             { 
    474                 get { return deleteIfEmpty; } 
    475                 set { deleteIfEmpty = value; } 
    476             } 
    477  
    478             private string includeMask = string.Empty; 
    479             private string excludeMask = string.Empty; 
    480             private bool deleteIfEmpty = true; 
    481         } 
    482  
    483         [Serializable] 
    484         public class RecycleBin : FilesystemObject 
    485         { 
    486             #region Serialization code 
    487             protected RecycleBin(SerializationInfo info, StreamingContext context) 
    488                 : base(info, context) 
    489             { 
    490             } 
    491             #endregion 
    492  
    493             public RecycleBin() 
    494             { 
    495             } 
    496  
    497             internal override List<string> GetPaths(out long totalSize) 
    498             { 
    499                 totalSize = 0; 
    500                 List<string> result = new List<string>(); 
    501                 string[] rootDirectory = new string[] { 
    502                     "$RECYCLE.BIN", 
    503                     "RECYCLER" 
    504                 }; 
    505  
    506                 foreach (DriveInfo drive in DriveInfo.GetDrives()) 
    507                 { 
    508                     foreach (string rootDir in rootDirectory) 
    509                     { 
    510                         DirectoryInfo dir = new DirectoryInfo( 
    511                             System.IO.Path.Combine( 
    512                                 System.IO.Path.Combine(drive.Name, rootDir), 
    513                                 System.Security.Principal.WindowsIdentity.GetCurrent(). 
    514                                     User.ToString())); 
    515                         if (!dir.Exists) 
    516                             continue; 
    517  
    518                         GetRecyclerFiles(dir, ref result, ref totalSize); 
    519                     } 
    520                 } 
    521  
    522                 return result; 
    523             } 
    524  
    525             /// <summary> 
    526             /// Retrieves all files within this folder, without exclusions. 
    527             /// </summary> 
    528             /// <param name="info">The DirectoryInfo object representing the folder to traverse.</param> 
    529             /// <param name="paths">The list of files to store path information in.</param> 
    530             /// <param name="totalSize">Receives the total size of the files.</param> 
    531             private void GetRecyclerFiles(DirectoryInfo info, ref List<string> paths, 
    532                 ref long totalSize) 
    533             { 
    534                 try 
    535                 { 
    536                     foreach (FileSystemInfo fsInfo in info.GetFileSystemInfos()) 
    537                     { 
    538                         if (fsInfo is FileInfo) 
    539                         { 
    540                             paths.Add(fsInfo.FullName); 
    541                             totalSize += ((FileInfo)fsInfo).Length; 
    542                             GetPathADSes(ref paths, ref totalSize, fsInfo.FullName); 
    543                         } 
    544                         else 
    545                             GetRecyclerFiles((DirectoryInfo)fsInfo, ref paths, ref totalSize); 
    546                     } 
    547                 } 
    548                 catch (UnauthorizedAccessException e) 
    549                 { 
    550                     Task.Log.Add(new LogEntry(e.Message, LogLevel.Error)); 
    551                 } 
    552             } 
    553  
    554             /// <summary> 
    555             /// Retrieves the text to display representing this task. 
    556             /// </summary> 
    557             public override string UIText 
    558             { 
    559                 get 
    560                 { 
    561                     return S._("Recycle Bin"); 
    562                 } 
    563             } 
    564         } 
    565  
    566         /// <summary> 
    567         /// Maintains a collection of erasure targets. 
    568         /// </summary> 
    569         [Serializable] 
    570         public class ErasureTargetsCollection : IList<ErasureTarget>, ICollection<ErasureTarget>, 
    571             IEnumerable<ErasureTarget>, ISerializable 
    572         { 
    573             #region Constructors 
    574             internal ErasureTargetsCollection(Task owner) 
    575             { 
    576                 this.list = new List<ErasureTarget>(); 
    577                 this.owner = owner; 
    578             } 
    579  
    580             internal ErasureTargetsCollection(Task owner, int capacity) 
    581                 : this(owner) 
    582             { 
    583                 list.Capacity = capacity; 
    584             } 
    585  
    586             internal ErasureTargetsCollection(Task owner, IEnumerable<ErasureTarget> targets) 
    587                 : this(owner) 
    588             { 
    589                 list.AddRange(targets); 
    590             } 
    591             #endregion 
    592  
    593             #region Serialization Code 
    594             protected ErasureTargetsCollection(SerializationInfo info, StreamingContext context) 
    595             { 
    596                 list = (List<ErasureTarget>)info.GetValue("list", typeof(List<ErasureTarget>)); 
    597             } 
    598  
    599             public virtual void GetObjectData(SerializationInfo info, StreamingContext context) 
    600             { 
    601                 info.AddValue("list", list); 
    602             } 
    603             #endregion 
    604  
    605             #region IEnumerable<ErasureTarget> Members 
    606             public IEnumerator<ErasureTarget> GetEnumerator() 
    607             { 
    608                 return list.GetEnumerator(); 
    609             } 
    610             #endregion 
    611  
    612             #region IEnumerable Members 
    613             System.Collections.IEnumerator System.Collections.IEnumerable.GetEnumerator() 
    614             { 
    615                 return list.GetEnumerator(); 
    616             } 
    617             #endregion 
    618  
    619             #region ICollection<ErasureTarget> Members 
    620             public void Add(ErasureTarget item) 
    621             { 
    622                 item.Task = owner; 
    623                 list.Add(item); 
    624             } 
    625  
    626             public void Clear() 
    627             { 
    628                 list.Clear(); 
    629             } 
    630  
    631             public bool Contains(ErasureTarget item) 
    632             { 
    633                 return list.Contains(item); 
    634             } 
    635  
    636             public void CopyTo(ErasureTarget[] array, int arrayIndex) 
    637             { 
    638                 list.CopyTo(array, arrayIndex); 
    639             } 
    640  
    641             public int Count 
    642             { 
    643                 get 
    644                 { 
    645                     return list.Count; 
    646                 } 
    647             } 
    648  
    649             public bool IsReadOnly 
    650             { 
    651                 get 
    652                 { 
    653                     return IsReadOnly; 
    654                 } 
    655             } 
    656  
    657             public bool Remove(ErasureTarget item) 
    658             { 
    659                 return list.Remove(item); 
    660             } 
    661             #endregion 
    662  
    663             #region IList<ErasureTarget> Members 
    664             public int IndexOf(ErasureTarget item) 
    665             { 
    666                 return list.IndexOf(item); 
    667             } 
    668  
    669             public void Insert(int index, ErasureTarget item) 
    670             { 
    671                 item.Task = owner; 
    672                 list.Insert(index, item); 
    673             } 
    674  
    675             public void RemoveAt(int index) 
    676             { 
    677                 list.RemoveAt(index); 
    678             } 
    679  
    680             public ErasureTarget this[int index] 
    681             { 
    682                 get 
    683                 { 
    684                     return list[index]; 
    685                 } 
    686                 set 
    687                 { 
    688                     list[index] = value; 
    689                 } 
    690             } 
    691             #endregion 
    692  
    693             /// <summary> 
    694             /// The ownere of this list of targets. 
    695             /// </summary> 
    696             public Task Owner 
    697             { 
    698                 get 
    699                 { 
    700                     return owner; 
    701                 } 
    702                 internal set 
    703                 { 
    704                     owner = value; 
    705                     foreach (ErasureTarget target in list) 
    706                         target.Task = owner; 
    707                 } 
    708             } 
    709  
    710             /// <summary> 
    711             /// The owner of this list of targets. All targets added to this list 
    712             /// will have the owner set to this object. 
    713             /// </summary> 
    714             private Task owner; 
    715  
    716             /// <summary> 
    717             /// The list bring the data store behind this object. 
    718             /// </summary> 
    719             List<ErasureTarget> list; 
    720         } 
    721  
    72239        #region Serialization code 
    72340        protected Task(SerializationInfo info, StreamingContext context) 
     
    74158        } 
    74259 
    743         public void GetObjectData(SerializationInfo info, StreamingContext context) 
     60        public virtual void GetObjectData(SerializationInfo info, StreamingContext context) 
    74461        { 
    74562            info.AddValue("ID", id); 
     
    76582        /// executions. 
    76683        /// </summary> 
    767         public uint ID 
     84        public uint Id 
    76885        { 
    76986            get { return id; } 
     
    804121                if (Targets.Count < 3) 
    805122                    //Simpler case, small set of data. 
    806                     foreach (Task.ErasureTarget tgt in Targets) 
     123                    foreach (ErasureTarget tgt in Targets) 
    807124                        result += tgt.UIText + ", "; 
    808125                else 
     
    943260 
    944261    /// <summary> 
     262    /// Represents a generic target of erasure 
     263    /// </summary> 
     264    [Serializable] 
     265    public abstract class ErasureTarget : ISerializable 
     266    { 
     267        #region Serialization code 
     268        protected ErasureTarget(SerializationInfo info, StreamingContext context) 
     269        { 
     270            Guid methodGuid = (Guid)info.GetValue("Method", typeof(Guid)); 
     271            if (methodGuid == Guid.Empty) 
     272                method = ErasureMethodManager.Default; 
     273            else 
     274                method = ErasureMethodManager.GetInstance(methodGuid); 
     275        } 
     276 
     277        public virtual void GetObjectData(SerializationInfo info, 
     278            StreamingContext context) 
     279        { 
     280            info.AddValue("Method", method.Guid); 
     281        } 
     282        #endregion 
     283 
     284        /// <summary> 
     285        /// Constructor. 
     286        /// </summary> 
     287        protected ErasureTarget() 
     288        { 
     289        } 
     290 
     291        /// <summary> 
     292        /// The method used for erasing the file. If the variable is equal to 
     293        /// ErasureMethodManager.Default then the default is queried for the 
     294        /// task type. 
     295        /// </summary> 
     296        public abstract ErasureMethod Method 
     297        { 
     298            get; 
     299            set; 
     300        } 
     301 
     302        /// <summary> 
     303        /// Checks whether a method has been selected for this target. This is 
     304        /// because the Method property will return non-default erasure methods 
     305        /// only. 
     306        /// </summary> 
     307        public bool MethodDefined 
     308        { 
     309            get 
     310            { 
     311                return method != ErasureMethodManager.Default; 
     312            } 
     313        } 
     314 
     315        /// <summary> 
     316        /// The task which owns this target. 
     317        /// </summary> 
     318        public Task Task 
     319        { 
     320            get 
     321            { 
     322                return task; 
     323            } 
     324            internal set 
     325            { 
     326                task = value; 
     327            } 
     328        } 
     329 
     330        /// <summary> 
     331        /// Retrieves the text to display representing this task. 
     332        /// </summary> 
     333        public abstract string UIText 
     334        { 
     335            get; 
     336        } 
     337 
     338        /// <summary> 
     339        /// Retrieves the amount of data that needs to be written in order to 
     340        /// complete the erasure. 
     341        /// </summary> 
     342        public abstract long TotalData 
     343        { 
     344            get; 
     345        } 
     346 
     347        /// <summary> 
     348        /// Erasure method to use for the target. 
     349        /// </summary> 
     350        protected ErasureMethod method { get; set; } 
     351 
     352        /// <summary> 
     353        /// The task object owning this target. 
     354        /// </summary> 
     355        private Task task; 
     356    } 
     357 
     358    /// <summary> 
     359    /// Class representing a tangible object (file/folder) to be erased. 
     360    /// </summary> 
     361    [Serializable] 
     362    public abstract class FileSystemObjectTarget : ErasureTarget 
     363    { 
     364        #region Serialization code 
     365        protected FileSystemObjectTarget(SerializationInfo info, StreamingContext context) 
     366            : base(info, context) 
     367        { 
     368            path = (string)info.GetValue("Path", typeof(string)); 
     369        } 
     370 
     371        override public void GetObjectData(SerializationInfo info, 
     372            StreamingContext context) 
     373        { 
     374            base.GetObjectData(info, context); 
     375            info.AddValue("Path", path); 
     376        } 
     377        #endregion 
     378 
     379        /// <summary> 
     380        /// Constructor. 
     381        /// </summary> 
     382        protected FileSystemObjectTarget() 
     383        { 
     384        } 
     385 
     386        /// <summary> 
     387        /// Retrieves the list of files/folders to erase as a list. 
     388        /// </summary> 
     389        /// <param name="totalSize">Returns the total size in bytes of the 
     390        /// items.</param> 
     391        /// <returns>A list containing the paths to all the files to be erased.</returns> 
     392        internal abstract List<string> GetPaths(out long totalSize); 
     393 
     394        /// <summary> 
     395        /// Adds ADSes of the given file to the list. 
     396        /// </summary> 
     397        /// <param name="list">The list to add the ADS paths to.</param> 
     398        /// <param name="file">The file to look for ADSes</param> 
     399        protected void GetPathADSes(ref List<string> list, ref long totalSize, string file) 
     400        { 
     401            try 
     402            { 
     403                //Get the ADS names 
     404                List<string> adses = Util.File.GetADSes(new FileInfo(file)); 
     405 
     406                //Then prepend the path. 
     407                foreach (string adsName in adses) 
     408                { 
     409                    string adsPath = file + ':' + adsName; 
     410                    list.Add(adsPath); 
     411                    Util.StreamInfo info = new Util.StreamInfo(adsPath); 
     412                    totalSize += info.Length; 
     413                } 
     414            } 
     415            catch (UnauthorizedAccessException e) 
     416            { 
     417                //The system cannot read the file, assume no ADSes for lack of 
     418                //more information. 
     419                Task.Log.Add(new LogEntry(e.Message, LogLevel.Error)); 
     420            } 
     421        } 
     422 
     423        /// <summary> 
     424        /// The path to the file or folder referred to by this object. 
     425        /// </summary> 
     426        public string Path 
     427        { 
     428            get { return path; } 
     429            set { path = value; } 
     430        } 
     431 
     432        public override ErasureMethod Method 
     433        { 
     434            get 
     435            { 
     436                if (method != ErasureMethodManager.Default) 
     437                    return method; 
     438                return ErasureMethodManager.GetInstance( 
     439                    ManagerLibrary.Instance.Settings.DefaultFileErasureMethod); 
     440            } 
     441            set 
     442            { 
     443                method = value; 
     444            } 
     445        } 
     446 
     447        public override string UIText 
     448        { 
     449            get { return Path; } 
     450        } 
     451 
     452        public override long TotalData 
     453        { 
     454            get 
     455            { 
     456                long totalSize = 0; 
     457                List<string> paths = GetPaths(out totalSize); 
     458                return Method.CalculateEraseDataSize(paths, totalSize); 
     459            } 
     460        } 
     461 
     462        private string path; 
     463    } 
     464 
     465    /// <summary> 
     466    /// Class representing a unused space erase. 
     467    /// </summary> 
     468    [Serializable] 
     469    public class UnusedSpaceTarget : ErasureTarget 
     470    { 
     471        #region Serialization code 
     472        protected UnusedSpaceTarget(SerializationInfo info, StreamingContext context) 
     473            : base(info, context) 
     474        { 
     475            Drive = (string)info.GetValue("Drive", typeof(string)); 
     476            EraseClusterTips = (bool)info.GetValue("EraseClusterTips", typeof(bool)); 
     477        } 
     478 
     479        public override void GetObjectData(SerializationInfo info, 
     480            StreamingContext context) 
     481        { 
     482            base.GetObjectData(info, context); 
     483            info.AddValue("Drive", Drive); 
     484            info.AddValue("EraseClusterTips", EraseClusterTips); 
     485        } 
     486        #endregion 
     487 
     488        /// <summary> 
     489        /// Constructor. 
     490        /// </summary> 
     491        public UnusedSpaceTarget() 
     492        { 
     493        } 
     494 
     495        public override ErasureMethod Method 
     496        { 
     497            get 
     498            { 
     499                if (method != ErasureMethodManager.Default) 
     500                    return method; 
     501                return ErasureMethodManager.GetInstance( 
     502                    ManagerLibrary.Instance.Settings.DefaultUnusedSpaceErasureMethod); 
     503            } 
     504            set 
     505            { 
     506                method = value; 
     507            } 
     508        } 
     509 
     510        public override string UIText 
     511        { 
     512            get { return S._("Unused disk space ({0})", Drive); } 
     513        } 
     514 
     515        public override long TotalData 
     516        { 
     517            get 
     518            { 
     519                VolumeInfo info = VolumeInfo.FromMountpoint(Drive); 
     520                return Method.CalculateEraseDataSize(null, info.AvailableFreeSpace); 
     521            } 
     522        } 
     523 
     524        /// <summary> 
     525        /// The drive to erase 
     526        /// </summary> 
     527        public string Drive { get; set; } 
     528 
     529        /// <summary> 
     530        /// Whether cluster tips should be erased. 
     531        /// </summary> 
     532        public bool EraseClusterTips { get; set; } 
     533    } 
     534 
     535    /// <summary> 
     536    /// Class representing a file to be erased. 
     537    /// </summary> 
     538    [Serializable] 
     539    public class FileTarget : FileSystemObjectTarget 
     540    { 
     541        #region Serialization code 
     542        protected FileTarget(SerializationInfo info, StreamingContext context) 
     543            : base(info, context) 
     544        { 
     545        } 
     546        #endregion 
     547 
     548        /// <summary> 
     549        /// Constructor. 
     550        /// </summary> 
     551        public FileTarget() 
     552        { 
     553        } 
     554 
     555        internal override List<string> GetPaths(out long totalSize) 
     556        { 
     557            List<string> result = new List<string>(); 
     558            totalSize = 0; 
     559            GetPathADSes(ref result, ref totalSize, Path); 
     560 
     561            totalSize += new FileInfo(Path).Length; 
     562            result.Add(Path); 
     563            return result; 
     564        } 
     565    } 
     566 
     567    /// <summary> 
     568    /// Represents a folder and its files which are to be erased. 
     569    /// </summary> 
     570    [Serializable] 
     571    public class FolderTarget : FileSystemObjectTarget 
     572    { 
     573        #region Serialization code 
     574        protected FolderTarget(SerializationInfo info, StreamingContext context) 
     575            : base(info, context) 
     576        { 
     577            includeMask = (string)info.GetValue("IncludeMask", typeof(string)); 
     578            excludeMask = (string)info.GetValue("ExcludeMask", typeof(string)); 
     579            deleteIfEmpty = (bool)info.GetValue("DeleteIfEmpty", typeof(bool)); 
     580        } 
     581 
     582        public override void GetObjectData(SerializationInfo info, 
     583            StreamingContext context) 
     584        { 
     585            base.GetObjectData(info, context); 
     586            info.AddValue("IncludeMask", includeMask); 
     587            info.AddValue("ExcludeMask", excludeMask); 
     588            info.AddValue("DeleteIfEmpty", deleteIfEmpty); 
     589        } 
     590        #endregion 
     591 
     592        /// <summary> 
     593        /// Constructor. 
     594        /// </summary> 
     595        public FolderTarget() 
     596        { 
     597        } 
     598 
     599        internal override List<string> GetPaths(out long totalSize) 
     600        { 
     601            //Get a list to hold all the resulting paths. 
     602            List<string> result = new List<string>(); 
     603 
     604            //Open the root of the search, including every file matching the pattern 
     605            DirectoryInfo dir = new DirectoryInfo(Path); 
     606 
     607            //List recursively all the files which match the include pattern. 
     608            string includeMask = IncludeMask; 
     609            if (includeMask.Length == 0) 
     610                includeMask = "*"; 
     611            FileInfo[] files = GetFiles(dir, includeMask); 
     612 
     613            //Then exclude each file and finalize the list and total file size 
     614            totalSize = 0; 
     615            if (ExcludeMask.Length != 0) 
     616            { 
     617                string regex = Regex.Escape(ExcludeMask).Replace("\\*", ".*"). 
     618                    Replace("\\?", "."); 
     619                Regex excludePattern = new Regex(regex, RegexOptions.IgnoreCase); 
     620                foreach (FileInfo file in files) 
     621                    if ((file.Attributes & FileAttributes.ReparsePoint) == 0 && 
     622                        excludePattern.Matches(file.FullName).Count == 0) 
     623                    { 
     624                        totalSize += file.Length; 
     625                        GetPathADSes(ref result, ref totalSize, file.FullName); 
     626                        result.Add(file.FullName); 
     627                    } 
     628            } 
     629            else 
     630                foreach (FileInfo file in files) 
     631                { 
     632                    if ((file.Attributes & FileAttributes.ReparsePoint) != 0) 
     633                        continue; 
     634 
     635                    totalSize += file.Length; 
     636                    GetPathADSes(ref result, ref totalSize, file.FullName); 
     637                    result.Add(file.FullName); 
     638                } 
     639 
     640            //Return the filtered list. 
     641            return result; 
     642        } 
     643 
     644        /// <summary> 
     645        /// Gets all files in the provided directory. 
     646        /// </summary> 
     647        /// <param name="info">The directory to look files in.</param> 
     648        /// <param name="includeMask">The include mask all files must match.</param> 
     649        /// <returns>A list of files found in the directory.</returns> 
     650        private FileInfo[] GetFiles(DirectoryInfo info, string includeMask) 
     651        { 
     652            List<FileInfo> result = new List<FileInfo>(); 
     653            foreach (DirectoryInfo dir in info.GetDirectories()) 
     654                try 
     655                { 
     656                    result.AddRange(GetFiles(dir, includeMask)); 
     657                } 
     658                catch (Exception e) 
     659                { 
     660                    //Ignore, but log. 
     661                    Task.Log.Add(new LogEntry(S._("Could not erase {0} because {1}", 
     662                        dir.FullName, e.Message), LogLevel.Error)); 
     663                } 
     664 
     665            result.AddRange(info.GetFiles(includeMask, SearchOption.TopDirectoryOnly)); 
     666            return result.ToArray(); 
     667        } 
     668 
     669        /// <summary> 
     670        /// A wildcard expression stating the condition for the set of files to include. 
     671        /// The include mask is applied before the exclude mask is applied. If this value 
     672        /// is empty, all files and folders within the folder specified is included. 
     673        /// </summary> 
     674        public string IncludeMask 
     675        { 
     676            get { return includeMask; } 
     677            set { includeMask = value; } 
     678        } 
     679 
     680        /// <summary> 
     681        /// A wildcard expression stating the condition for removing files from the set 
     682        /// of included files. If this value is omitted, all files and folders extracted 
     683        /// by the inclusion mask is erased. 
     684        /// </summary> 
     685        public string ExcludeMask 
     686        { 
     687            get { return excludeMask; } 
     688            set { excludeMask = value; } 
     689        } 
     690 
     691        /// <summary> 
     692        /// Determines if Eraser should delete the folder after the erase process. 
     693        /// </summary> 
     694        public bool DeleteIfEmpty 
     695        { 
     696            get { return deleteIfEmpty; } 
     697            set { deleteIfEmpty = value; } 
     698        } 
     699 
     700        private string includeMask = string.Empty; 
     701        private string excludeMask = string.Empty; 
     702        private bool deleteIfEmpty = true; 
     703    } 
     704 
     705    [Serializable] 
     706    public class RecycleBinTarget : FileSystemObjectTarget 
     707    { 
     708        #region Serialization code 
     709        protected RecycleBinTarget(SerializationInfo info, StreamingContext context) 
     710            : base(info, context) 
     711        { 
     712        } 
     713        #endregion 
     714 
     715        public RecycleBinTarget() 
     716        { 
     717        } 
     718 
     719        internal override List<string> GetPaths(out long totalSize) 
     720        { 
     721            totalSize = 0; 
     722            List<string> result = new List<string>(); 
     723            string[] rootDirectory = new string[] { 
     724                    "$RECYCLE.BIN", 
     725                    "RECYCLER" 
     726                }; 
     727 
     728            foreach (DriveInfo drive in DriveInfo.GetDrives()) 
     729            { 
     730                foreach (string rootDir in rootDirectory) 
     731                { 
     732                    DirectoryInfo dir = new DirectoryInfo( 
     733                        System.IO.Path.Combine( 
     734                            System.IO.Path.Combine(drive.Name, rootDir), 
     735                            System.Security.Principal.WindowsIdentity.GetCurrent(). 
     736                                User.ToString())); 
     737                    if (!dir.Exists) 
     738                        continue; 
     739 
     740                    GetRecyclerFiles(dir, ref result, ref totalSize); 
     741                } 
     742            } 
     743 
     744            return result; 
     745        } 
     746 
     747        /// <summary> 
     748        /// Retrieves all files within this folder, without exclusions. 
     749        /// </summary> 
     750        /// <param name="info">The DirectoryInfo object representing the folder to traverse.</param> 
     751        /// <param name="paths">The list of files to store path information in.</param> 
     752        /// <param name="totalSize">Receives the total size of the files.</param> 
     753        private void GetRecyclerFiles(DirectoryInfo info, ref List<string> paths, 
     754            ref long totalSize) 
     755        { 
     756            try 
     757            { 
     758                foreach (FileSystemInfo fsInfo in info.GetFileSystemInfos()) 
     759                { 
     760                    if (fsInfo is FileInfo) 
     761                    { 
     762                        paths.Add(fsInfo.FullName); 
     763                        totalSize += ((FileInfo)fsInfo).Length; 
     764                        GetPathADSes(ref paths, ref totalSize, fsInfo.FullName); 
     765                    } 
     766                    else 
     767                        GetRecyclerFiles((DirectoryInfo)fsInfo, ref paths, ref totalSize); 
     768                } 
     769            } 
     770            catch (UnauthorizedAccessException e) 
     771            { 
     772                Task.Log.Add(new LogEntry(e.Message, LogLevel.Error)); 
     773            } 
     774        } 
     775 
     776        /// <summary> 
     777        /// Retrieves the text to display representing this task. 
     778        /// </summary> 
     779        public override string UIText 
     780        { 
     781            get 
     782            { 
     783                return S._("Recycle Bin"); 
     784            } 
     785        } 
     786    } 
     787 
     788    /// <summary> 
     789    /// Maintains a collection of erasure targets. 
     790    /// </summary> 
     791    [Serializable] 
     792    public class ErasureTargetsCollection : IList<ErasureTarget>, ICollection<ErasureTarget>, 
     793        IEnumerable<ErasureTarget>, ISerializable 
     794    { 
     795        #region Constructors 
     796        internal ErasureTargetsCollection(Task owner) 
     797        { 
     798            this.list = new List<ErasureTarget>(); 
     799            this.owner = owner; 
     800        } 
     801 
     802        internal ErasureTargetsCollection(Task owner, int capacity) 
     803            : this(owner) 
     804        { 
     805            list.Capacity = capacity; 
     806        } 
     807 
     808        internal ErasureTargetsCollection(Task owner, IEnumerable<ErasureTarget> targets) 
     809            : this(owner) 
     810        { 
     811            list.AddRange(targets); 
     812        } 
     813        #endregion 
     814 
     815        #region Serialization Code 
     816        protected ErasureTargetsCollection(SerializationInfo info, StreamingContext context) 
     817        { 
     818            list = (List<ErasureTarget>)info.GetValue("list", typeof(List<ErasureTarget>)); 
     819        } 
     820 
     821        public virtual void GetObjectData(SerializationInfo info, StreamingContext context) 
     822        { 
     823            info.AddValue("list", list); 
     824        } 
     825        #endregion 
     826 
     827        #region IEnumerable<ErasureTarget> Members 
     828        public IEnumerator<ErasureTarget> GetEnumerator() 
     829        { 
     830            return list.GetEnumerator(); 
     831        } 
     832        #endregion 
     833 
     834        #region IEnumerable Members 
     835        System.Collections.IEnumerator System.Collections.IEnumerable.GetEnumerator() 
     836        { 
     837            return list.GetEnumerator(); 
     838        } 
     839        #endregion 
     840 
     841        #region ICollection<ErasureTarget> Members 
     842        public void Add(ErasureTarget item) 
     843        { 
     844            item.Task = owner; 
     845            list.Add(item); 
     846        } 
     847 
     848        public void Clear() 
     849        { 
     850            list.Clear(); 
     851        } 
     852 
     853        public bool Contains(ErasureTarget item) 
     854        { 
     855            return list.Contains(item); 
     856        } 
     857 
     858        public void CopyTo(ErasureTarget[] array, int arrayIndex) 
     859        { 
     860            list.CopyTo(array, arrayIndex); 
     861        } 
     862 
     863        public int Count 
     864        { 
     865            get 
     866            { 
     867                return list.Count; 
     868            } 
     869        } 
     870 
     871        public bool IsReadOnly 
     872        { 
     873            get 
     874            { 
     875                return IsReadOnly; 
     876            } 
     877        } 
     878 
     879        public bool Remove(ErasureTarget item) 
     880        { 
     881            return list.Remove(item); 
     882        } 
     883        #endregion 
     884 
     885        #region IList<ErasureTarget> Members 
     886        public int IndexOf(ErasureTarget item) 
     887        { 
     888            return list.IndexOf(item); 
     889        } 
     890 
     891        public void Insert(int index, ErasureTarget item) 
     892        { 
     893            item.Task = owner; 
     894            list.Insert(index, item); 
     895        } 
     896 
     897        public void RemoveAt(int index) 
     898        { 
     899            list.RemoveAt(index); 
     900        } 
     901 
     902        public ErasureTarget this[int index] 
     903        { 
     904            get 
     905            { 
     906                return list[index]; 
     907            } 
     908            set 
     909            { 
     910                list[index] = value; 
     911            } 
     912        } 
     913        #endregion 
     914 
     915        /// <summary> 
     916        /// The ownere of this list of targets. 
     917        /// </summary> 
     918        public Task Owner 
     919        { 
     920            get 
     921            { 
     922                return owner; 
     923            } 
     924            internal set 
     925            { 
     926                owner = value; 
     927                foreach (ErasureTarget target in list) 
     928                    target.Task = owner; 
     929            } 
     930        } 
     931 
     932        /// <summary> 
     933        /// The owner of this list of targets. All targets added to this list 
     934        /// will have the owner set to this object. 
     935        /// </summary> 
     936        private Task owner; 
     937 
     938        /// <summary> 
     939        /// The list bring the data store behind this object. 
     940        /// </summary> 
     941        List<ErasureTarget> list; 
     942    } 
     943 
     944    /// <summary> 
    945945    /// A base event class for all event arguments involving a task. 
    946946    /// </summary> 
     
    10011001        /// The current erasure target - the current item being erased. 
    10021002        /// </summary> 
    1003         public Task.ErasureTarget CurrentTarget 
     1003        public ErasureTarget CurrentTarget 
    10041004        { 
    10051005            get { return currentTarget; } 
     
    10691069        private TimeSpan timeLeft = new TimeSpan(0, 0, -1); 
    10701070 
    1071         private Task.ErasureTarget currentTarget; 
     1071        private ErasureTarget currentTarget; 
    10721072        private int currentTargetIndex; 
    10731073        private int currentTargetTotalPasses; 
Note: See TracChangeset for help on using the changeset viewer.