source: branches/eraser6/Manager/Task.cs @ 213

Revision 213, 10.7 KB checked in by lowjoel, 6 years ago (diff)

-Define the Task start and completion events
-Added the UIText property. This was a copy from the GenerateTaskName? function in the Scheduler panel earlier
-Added the TaskEventArgs? base class to allow for other simpler events (mainly start and finish events)
-Added the current erasure target for erase tasks.

Line 
1using System;
2using System.Collections.Generic;
3using System.Text;
4using System.IO;
5using System.Text.RegularExpressions;
6using System.ComponentModel;
7
8namespace Eraser.Manager
9{
10    /// <summary>
11    /// Deals with an erase task.
12    /// </summary>
13    public class Task
14    {
15        /// <summary>
16        /// Represents a generic target of erasure
17        /// </summary>
18        public abstract class ErasureTarget
19        {
20            /// <summary>
21            /// The method used for erasing the file. If the variable is equal to
22            /// ErasureMethodManager.Default then the default is queried for the
23            /// task type.
24            /// </summary>
25            public ErasureMethod Method
26            {
27                get { return method; }
28                set { method = value; }
29            }
30
31            /// <summary>
32            /// Retrieves the text to display representing this task.
33            /// </summary>
34            public abstract string UIText
35            {
36                get;
37            }
38
39            private ErasureMethod method = null;
40        }
41
42        /// <summary>
43        /// Class representing a tangible object (file/folder) to be erased.
44        /// </summary>
45        public abstract class FilesystemObject : ErasureTarget
46        {
47            /// <summary>
48            /// Retrieves the list of files/folders to erase as a list.
49            /// </summary>
50            /// <returns></returns>
51            internal abstract List<string> GetPaths();
52
53            /// <summary>
54            /// The path to the file or folder referred to by this object.
55            /// </summary>
56            public string Path
57            {
58                get { return path; }
59                set { path = value; }
60            }
61
62            public override string UIText
63            {
64                get { return Path; }
65            }
66
67            private string path;
68        }
69
70        /// <summary>
71        /// Class representing a unused space erase.
72        /// </summary>
73        public class UnusedSpace : ErasureTarget
74        {
75            public string Drive;
76
77            public override string UIText
78            {
79                get { return string.Format("Unused disk space ({0})", Drive); }
80            }
81        }
82
83        /// <summary>
84        /// Class representing a file to be erased.
85        /// </summary>
86        public class File : FilesystemObject
87        {
88            internal override List<string> GetPaths()
89            {
90                List<string> result = new List<string>();
91                result.Add(Path);
92                return result;
93            }
94        }
95
96        /// <summary>
97        /// Represents a folder and its files which are to be erased.
98        /// </summary>
99        public class Folder : FilesystemObject
100        {
101            internal override List<string> GetPaths()
102            {
103                //Get a list to hold all the resulting paths.
104                List<string> result = new List<string>();
105
106                //Open the root of the search, including every file matching the pattern
107                DirectoryInfo dir = new DirectoryInfo(Path);
108
109                //List recursively all the files which match the include pattern.
110                string includeMask = IncludeMask;
111                if (includeMask.Length == 0)
112                    includeMask = "*.*";
113                FileInfo[] files = dir.GetFiles(includeMask, SearchOption.AllDirectories);
114
115                //Then exclude each file.
116                if (ExcludeMask.Length != 0)
117                {
118                    string regex = Regex.Escape(ExcludeMask).Replace("\\*", ".*").
119                        Replace("\\?", ".");
120                    Regex excludePattern = new Regex(regex, RegexOptions.IgnoreCase);
121                    foreach (FileInfo file in files)
122                        if (excludePattern.Matches(file.FullName).Count == 0)
123                            result.Add(file.FullName);
124                }
125                else
126                    foreach (FileInfo file in files)
127                        result.Add(file.FullName);
128               
129                //Return the filtered list.
130                return result;
131            }
132
133            /// <summary>
134            /// A wildcard expression stating the condition for the set of files to include.
135            /// The include mask is applied before the exclude mask is applied. If this value
136            /// is empty, all files and folders within the folder specified is included.
137            /// </summary>
138            public string IncludeMask
139            {
140                get { return includeMask; }
141                set { includeMask = value; }
142            }
143
144            /// <summary>
145            /// A wildcard expression stating the condition for removing files from the set
146            /// of included files. If this value is omitted, all files and folders extracted
147            /// by the inclusion mask is erased.
148            /// </summary>
149            public string ExcludeMask
150            {
151                get { return excludeMask; }
152                set { excludeMask = value; }
153            }
154
155            /// <summary>
156            /// Determines if Eraser should delete the folder after the erase process.
157            /// </summary>
158            public bool DeleteIfEmpty
159            {
160                get { return deleteIfEmpty; }
161                set { deleteIfEmpty = value; }
162            }
163
164            private string includeMask;
165            private string excludeMask;
166            private bool deleteIfEmpty;
167        }
168
169        /// <summary>
170        /// The unique identifier for this task. This ID will be persistent across
171        /// executions.
172        /// </summary>
173        public uint ID
174        {
175            get { return id; }
176        }
177
178        /// <summary>
179        /// The name for this task. This is just an opaque value for the user to
180        /// recognize the task.
181        /// </summary>
182        public string Name
183        {
184            get { return name; }
185            set { name = value; }
186        }
187
188        /// <summary>
189        /// The name of the task, used for display in UI elements.
190        /// </summary>
191        public string UIText
192        {
193            get
194            {
195                //Simple case, the task name was given by the user.
196                if (Name.Length != 0)
197                    return Name;
198
199                string result = string.Empty;
200                if (Entries.Count < 3)
201                    //Simpler case, small set of data.
202                    foreach (Task.ErasureTarget tgt in Entries)
203                        result += tgt.UIText + ", ";
204                else
205                    //Ok, we've quite a few entries, get the first, the mid and the end.
206                    for (int i = 0; i < Entries.Count; i += Entries.Count / 3)
207                        result += Entries[i].UIText + ", ";
208                return result.Substring(0, result.Length - 2);
209            }
210        }
211
212        /// <summary>
213        /// Gets the status of the task - whether it is being executed.
214        /// </summary>
215        public bool Executing
216        {
217            get { return executing; }
218        }
219
220        /// <summary>
221        /// The set of data to erase when this task is executed.
222        /// </summary>
223        public List<ErasureTarget> Entries
224        {
225            get { return entries; }
226            set { entries = value; }
227        }
228
229        /// <summary>
230        /// The schedule for running the task.
231        /// </summary>
232        public Schedule Schedule
233        {
234            get { return schedule; }
235            set { schedule = value; }
236        }
237
238        /// <summary>
239        /// Retrieves the log for this task.
240        /// </summary>
241        public List<LogEntry> Log
242        {
243            get
244            {
245                lock (log)
246                    return log.GetRange(0, log.Count);
247            }
248        }
249
250        /// <summary>
251        /// Logs the message and its associated information into the task Log.
252        /// </summary>
253        /// <param name="entry">The log entry structure representing the log
254        /// message.</param>
255        internal void LogEntry(LogEntry entry)
256        {
257            lock (log)
258                log.Add(entry);
259        }
260
261        #region Events
262        /// <summary>
263        /// The prototype for events handling just a task object as the event argument.
264        /// </summary>
265        /// <param name="e">The task object.</param>
266        public delegate void TaskEventFunction(TaskEventArgs e);
267
268        /// <summary>
269        /// The prototype for events handling the progress changed event.
270        /// </summary>
271        /// <param name="e">The new progress value.</param>
272        public delegate void ProgressEventFunction(TaskProgressEventArgs e);
273
274        /// <summary>
275        /// The start of the execution of a task.
276        /// </summary>
277        public event TaskEventFunction TaskStarted;
278
279        /// <summary>
280        /// The event object holding all event handlers.
281        /// </summary>
282        public event ProgressEventFunction ProgressChanged;
283
284        /// <summary>
285        /// The completion of the execution of a task.
286        /// </summary>
287        public event TaskEventFunction TaskFinished;
288
289        /// <summary>
290        /// Broadcasts the task execution start event.
291        /// </summary>
292        /// <param name="e"></param>
293        internal void OnTaskStarted(TaskEventArgs e)
294        {
295            if (TaskStarted != null)
296                TaskStarted.Invoke(e);
297            executing = true;
298        }
299
300        /// <summary>
301        /// Broadcasts a ProgressChanged event.
302        /// </summary>
303        /// <param name="e">The new progress value.</param>
304        internal void OnProgressChanged(TaskProgressEventArgs e)
305        {
306            if (ProgressChanged != null)
307                ProgressChanged.Invoke(e);
308        }
309
310        /// <summary>
311        /// Broadcasts the task execution completion event.
312        /// </summary>
313        /// <param name="e"></param>
314        internal void OnTaskFinished(TaskEventArgs e)
315        {
316            if (TaskFinished != null)
317                TaskFinished.Invoke(e);
318            executing = false;
319        }
320        #endregion
321
322        internal uint id;
323        private string name;
324        private bool executing;
325
326        private Schedule schedule = Schedule.RunNow;
327        private List<ErasureTarget> entries = new List<ErasureTarget>();
328        private List<LogEntry> log = new List<LogEntry>();
329    }
330
331    /// <summary>
332    /// A base event class for all event arguments involving a task.
333    /// </summary>
334    public class TaskEventArgs : EventArgs
335    {
336        /// <summary>
337        /// Constructor.
338        /// </summary>
339        /// <param name="task">The task being run.</param>
340        public TaskEventArgs(Task task)
341        {
342            this.task = task;
343        }
344
345        /// <summary>
346        /// The executing task.
347        /// </summary>
348        public Task Task
349        {
350            get { return task; }
351        }
352
353        private Task task;
354    }
355
356    /// <summary>
357    /// A Event argument object containing the progress of the task.
358    /// </summary>
359    public class TaskProgressEventArgs : TaskEventArgs
360    {
361        /// <summary>
362        /// Constructor.
363        /// </summary>
364        /// <param name="task">The task being run.</param>
365        /// <param name="overallProgress">The overall progress of the task.</param>
366        /// <param name="currentItemProgress">The progress for the individual
367        /// component of the task.</param>
368        public TaskProgressEventArgs(Task task, int overallProgress,
369            int currentItemProgress)
370            : base(task)
371        {
372            this.overallProgress = overallProgress;
373            this.currentItemProgress = currentItemProgress;
374        }
375
376        /// <summary>
377        /// A number from 0 to 100 detailing the overall progress of the task.
378        /// </summary>
379        public int OverallProgress
380        {
381            get { return overallProgress; }
382        }
383
384        /// <summary>
385        /// The current erasure target - the current item being erased.
386        /// </summary>
387        public Task.ErasureTarget CurrentTarget
388        {
389            get { return currentTarget; }
390        }
391
392        /// <summary>
393        /// A number from 0 to 100 detailing the overall progress of the item.
394        /// </summary>
395        public int CurrentItemProgress
396        {
397            get { return currentItemProgress; }
398        }
399
400        /// <summary>
401        /// The file name of the item being erased.
402        /// </summary>
403        public string CurrentItemName
404        {
405            get { return currentItemName; }
406        }
407
408        /// <summary>
409        /// The pass number of a multi-pass erasure method.
410        /// </summary>
411        public int CurrentPass
412        {
413            get { return currentPass; }
414        }
415
416        /// <summary>
417        /// The total number of passes to complete before this erasure method is
418        /// completed.
419        /// </summary>
420        public int TotalPasses
421        {
422            get { return totalPasses; }
423        }
424
425        internal int overallProgress;
426        internal Task.ErasureTarget currentTarget;
427        internal int currentItemProgress;
428        internal string currentItemName;
429        internal int currentPass = 1;
430        internal int totalPasses;
431    }
432}
Note: See TracBrowser for help on using the repository browser.