Changeset 1512

Timestamp:

1/13/2010 3:21:44 AM (2 years ago)

Author:

lowjoel

Message:

Defined the standard callback prototype. We have our own ProgressChangedEventArgs?, modelled after the System.ComponentModel?.ProgressChangedEventArgs?, and likewise, a similar handler interface.

Location:

branches/eraser6/SpeedMeter

Files:

• Eraser.Manager/DirectExecutor.cs (modified) (11 diffs)
• Eraser.Manager/ProgressManager.cs (modified) (1 diff)
• Eraser.Manager/Task.cs (modified) (3 diffs)
• Eraser/ProgressForm.cs (modified) (4 diffs)
• Eraser/SchedulerPanel.cs (modified) (4 diffs)

branches/eraser6/SpeedMeter/Eraser.Manager/DirectExecutor.cs

@@ -383 +383 @@
                             throw new OperationCanceledException(S._("The task was cancelled."));
 
-                        task.OnProgressChanged(target, new TaskProgressEventArgs(task,
-                            path, 0, 0));
+                        task.OnProgressChanged(target,
+                            new ProgressChangedEventArgs(tipSearch,
+                                new TaskProgressChangedEventArgs(path, 0, 0)));
                     };
 
@@ -396 +397 @@
                         tipProgress.Total = totalFiles;
                         tipProgress.Completed = currentFile;
-                        task.OnProgressChanged(target, new TaskProgressEventArgs(task,
-                            currentFilePath, 0, 0));
+                        task.OnProgressChanged(target,
+                            new ProgressChangedEventArgs(tipProgress,
+                                new TaskProgressChangedEventArgs(currentFilePath, 0, 0)));
 
                         if (currentTask.Canceled)
@@ -459 +461 @@
                             {
                                 mainProgress.Completed += lastWritten;
-                                task.OnProgressChanged(target, new TaskProgressEventArgs(task,
-                                    target.Drive, currentPass, method.Passes));
+                                task.OnProgressChanged(target,
+                                    new ProgressChangedEventArgs(mainProgress,
+                                        new TaskProgressChangedEventArgs(target.Drive, currentPass, method.Passes)));
 
                                 if (currentTask.Canceled)
@@ -481 +484 @@
                         residentProgress.Completed = currentFile;
                         residentProgress.Total = totalFiles;
-                        task.OnProgressChanged(target, new TaskProgressEventArgs(task,
-                            string.Empty, 0, 0));
+                        task.OnProgressChanged(target,
+                            new ProgressChangedEventArgs(residentProgress,
+                                new TaskProgressChangedEventArgs(string.Empty, 0, 0)));
 
                         if (currentTask.Canceled)
@@ -497 +501 @@
                 progress.Steps.Add(new SteppedProgressManager.Step(tempFiles,
                     0.0f, S._("Removing temporary files...")));
-                task.OnProgressChanged(target, new TaskProgressEventArgs(task, string.Empty, 0, 0));
+                task.OnProgressChanged(target, new ProgressChangedEventArgs(tempFiles,
+                    new TaskProgressChangedEventArgs(string.Empty, 0, 0)));
                 fsManager.DeleteFolder(info);
                 tempFiles.Completed = tempFiles.Total = 1;
@@ -517 +522 @@
 
                     //Set the event parameters, then broadcast the progress event.
-                    task.OnProgressChanged(target, new TaskProgressEventArgs(task,
-                        string.Empty, 0, 0));
+                    task.OnProgressChanged(target,
+                        new ProgressChangedEventArgs(structureProgress,
+                            new TaskProgressChangedEventArgs(string.Empty, 0, 0)));
                 }
             );
@@ -557 +563 @@
                 progress.Steps.Add(new SteppedProgressManager.Step(step,
                     1.0f / paths.Count, S._("Erasing files...")));
-                task.OnProgressChanged(target, new TaskProgressEventArgs(
-                    task, paths[i], 0, method.Passes));
+                task.OnProgressChanged(target,
+                    new ProgressChangedEventArgs(step,
+                        new TaskProgressChangedEventArgs(paths[i], 0, method.Passes)));
                 
                 //Get the filesystem provider to handle the secure file erasures
@@ -601 +608 @@
                             step.Completed += lastWritten;
                             step.Total = totalData;
-                            task.OnProgressChanged(target, new TaskProgressEventArgs(task,
-                                info.FullName, currentPass, method.Passes));
+                            task.OnProgressChanged(target,
+                                new ProgressChangedEventArgs(step,
+                                    new TaskProgressChangedEventArgs(info.FullName, currentPass, method.Passes)));
                         });
 
@@ -659 +667 @@
                      foreach (DirectoryInfo subDir in info.GetDirectories())
                          eraseEmptySubFolders(subDir);
-                     task.OnProgressChanged(target, new TaskProgressEventArgs(
-                         task, info.FullName, 0, 0));
+                     task.OnProgressChanged(target,
+                         new ProgressChangedEventArgs(step,
+                             new TaskProgressChangedEventArgs(info.FullName, 0, 0)));
 
                      FileSystemInfo[] files = info.GetFileSystemInfos();
@@ -671 +680 @@
                 {
                     DirectoryInfo info = new DirectoryInfo(fldr.Path);
-                    task.OnProgressChanged(target, new TaskProgressEventArgs(
-                         task, info.FullName, 0, 0));
+                    task.OnProgressChanged(target,
+                        new ProgressChangedEventArgs(step,
+                            new TaskProgressChangedEventArgs(info.FullName, 0, 0)));
 
                     //See if this is the root of a volume.
@@ -694 +704 @@
                 progress.Steps.Add(new SteppedProgressManager.Step(step,
                     0.0f, S._("Emptying recycle bin...")));
-                task.OnProgressChanged(target, new TaskProgressEventArgs(task, string.Empty, 0, 0));
+                task.OnProgressChanged(target,
+                    new ProgressChangedEventArgs(step,
+                        new TaskProgressChangedEventArgs(string.Empty, 0, 0)));
 
                 ShellApi.EmptyRecycleBin(EmptyRecycleBinOptions.NoConfirmation |

branches/eraser6/SpeedMeter/Eraser.Manager/ProgressManager.cs

@@ -702 +702 @@
         private object TaskLock;
     }
+
+    /// <summary>
+    /// Provides data for the Eraser.Manager.ProgressChanged event.
+    /// </summary>
+    public class ProgressChangedEventArgs : EventArgs
+    {
+        /// <summary>
+        /// Constructor.
+        /// </summary>
+        /// <param name="progress">The ProgressManagerBase object that stores the progress
+        /// for the given task.</param>
+        /// <param name="userState">A client-specified state object.</param>
+        public ProgressChangedEventArgs(ProgressManagerBase progress, object userState)
+        {
+            Progress = progress;
+            UserState = userState;
+        }
+
+        /// <summary>
+        /// The ProgressManagerBase object that stores the progress for the given
+        /// task.
+        /// </summary>
+        public ProgressManagerBase Progress { get; private set; }
+
+        /// <summary>
+        /// A client-specified state object.
+        /// </summary>
+        public object UserState { get; private set; }
+    }
+
+    /// <summary>
+    /// Represents the method that will handle the ProgressChanged event from
+    /// the <see cref="ProgressManagerBase"/> class.
+    /// </summary>
+    /// <param name="sender">The source of the event.</param>
+    /// <param name="e">A <see cref="ProgressChangedEventArgs"/> event that
+    /// stores the event data.</param>
+    public delegate void ProgressChangedEventHandler(object sender, ProgressChangedEventArgs e);
 }

branches/eraser6/SpeedMeter/Eraser.Manager/Task.cs

@@ -235 +235 @@
         /// The event object holding all event handlers.
         /// </summary>
-        public EventHandler<TaskProgressEventArgs> ProgressChanged { get; set; }
+        public EventHandler<ProgressChangedEventArgs> ProgressChanged { get; set; }
 
         /// <summary>
@@ -264 +264 @@
 
         /// <summary>
-        /// Broadcasts a ProgressChanged event.
+        /// Broadcasts a ProgressChanged event. The sender will be the erasure target
+        /// which broadcast this event; e.UserState will contain extra information
+        /// about the progress which is stored as a TaskProgressChangedEventArgs
+        /// object.
         /// </summary>
         /// <param name="sender">The <see cref="ErasureTarget"/> which is reporting
         /// progress.</param>
         /// <param name="e">The new progress value.</param>
-        internal void OnProgressChanged(ErasureTarget sender, TaskProgressEventArgs e)
-        {
+        /// <exception cref="ArgumentException">e.UserState must be of the type
+        /// <see cref="TaskProgressEventargs"/></exception>
+        /// <exception cref="ArgumentNullException">Both sender and e cannot be null.</exception>
+        internal void OnProgressChanged(ErasureTarget sender, ProgressChangedEventArgs e)
+        {
+            if (sender == null)
+                throw new ArgumentNullException("sender");
+            if (e == null)
+                throw new ArgumentNullException("sender");
+            if (e.UserState.GetType() != typeof(TaskProgressChangedEventArgs))
+                throw new ArgumentException("The Task.OnProgressChanged event expects a " +
+                    "TaskProgressEventArgs argument for the ProgressChangedEventArgs' UserState " +
+                    "object.", "e");
+
             if (ProgressChanged != null)
                 ProgressChanged(sender, e);
@@ -1011 +1026 @@
     }
 
-    public class TaskProgressEventArgs : TaskEventArgs
+    /// <summary>
+    /// Stores extra information in the <see cref="ProgressChangedEventArgs"/>
+    /// structure that is not conveyed in the ProgressManagerBase classes.
+    /// </summary>
+    public class TaskProgressChangedEventArgs
     {
         /// <summary>
         /// Constructor.
         /// </summary>
-        /// <param name="task">The task being referred to by this event.</param>
         /// <param name="itemName">The item whose erasure progress is being erased.</param>
         /// <param name="itemPass">The current pass number for this item.</param>
         /// <param name="itemTotalPasses">The total number of passes to complete erasure
         /// of this item.</param>
-        public TaskProgressEventArgs(Task task, string itemName, int itemPass,
+        public TaskProgressChangedEventArgs(string itemName, int itemPass,
             int itemTotalPasses)
-            : base(task)
         {
             ItemName = itemName;

branches/eraser6/SpeedMeter/Eraser/ProgressForm.cs

@@ -31 +31 @@
 using Eraser.Util;
 using System.Globalization;
+using ProgressChangedEventArgs = Eraser.Manager.ProgressChangedEventArgs;
 
 namespace Eraser
@@ -63 +64 @@
         }
 
-        private void task_ProgressChanged(object sender, TaskProgressEventArgs e)
+        private void task_ProgressChanged(object sender, ProgressChangedEventArgs e)
         {
             if (InvokeRequired)
@@ -72 +73 @@
 
                 lastUpdate = DateTime.Now;
-                Invoke(new EventHandler<TaskProgressEventArgs>(task_ProgressChanged), sender, e);
+                Invoke((EventHandler<ProgressChangedEventArgs>)task_ProgressChanged, sender, e);
                 return;
             }
@@ -144 +145 @@
         }
 
-        private void UpdateProgress(SteppedProgressManager targetProgress, TaskProgressEventArgs e)
-        {
+        private void UpdateProgress(SteppedProgressManager targetProgress, ProgressChangedEventArgs e)
+        {
+            TaskProgressChangedEventArgs e2 = (TaskProgressChangedEventArgs)e.UserState;
+
             status.Text = targetProgress.CurrentStep.Name;
-
-            if (e != null)
-            {
-                item.Text = WrapItemName(e.ItemName);
-                pass.Text = e.ItemTotalPasses != 0 ?
-                    S._("{0} out of {1}", e.ItemPass, e.ItemTotalPasses) :
-                    e.ItemPass.ToString(CultureInfo.CurrentCulture);
+            if (e2 != null)
+            {
+                item.Text = WrapItemName(e2.ItemName);
+                pass.Text = e2.ItemTotalPasses != 0 ?
+                    S._("{0} out of {1}", e2.ItemPass, e2.ItemTotalPasses) :
+                    e2.ItemPass.ToString(CultureInfo.CurrentCulture);
             }
 

branches/eraser6/SpeedMeter/Eraser/SchedulerPanel.cs

@@ -22 +22 @@
 using System;
 using System.Collections.Generic;
-using System.ComponentModel;
 using System.Data;
 using System.Drawing;
@@ -35 +34 @@
 using System.IO;
 using System.Runtime.Serialization;
+using System.ComponentModel;
+using ProgressChangedEventArgs = Eraser.Manager.ProgressChangedEventArgs;
 
 namespace Eraser
@@ -207 +208 @@
         /// Handles the progress event by the task.
         /// </summary>
-        void task_ProgressChanged(object sender, TaskEventArgs e)
+        void task_ProgressChanged(object sender, ProgressChangedEventArgs e)
         {
             //Make sure we handle the event in the main thread as this requires
@@ -213 +214 @@
             if (scheduler.InvokeRequired)
             {
-                Invoke(new EventHandler<TaskEventArgs>(task_ProgressChanged), sender, e);
+                Invoke((EventHandler<ProgressChangedEventArgs>)task_ProgressChanged, sender, e);
                 return;
             }
 
             //Update the progress bar
-            schedulerProgress.Value = (int)(e.Task.Progress.Progress * 1000.0);
+            ErasureTarget target = (ErasureTarget)sender;
+            schedulerProgress.Value = (int)(target.Task.Progress.Progress * 1000.0);
         }