Changeset 1503


Ignore:
Timestamp:
1/12/2010 3:02:04 AM (5 years ago)
Author:
lowjoel
Message:

Current revision finally compiles.
-Instead of having a separate class for stepped progress handlers, it occurred to me that when nesting we may not be nesting a SteppedProgressManagerStep? (e,g, the Task is a SteppedProgressManager? but the steps are not: they are SteppedProgressManagers? in their own right) so instead hold the step information in an external structure (SteppedProgressManager?.Step)
-Fixed the foreach loops in the ParallelProgressManager?.
-I wanted to get rid of the TaskProgressEventArgs? class, but looks like it can't be removed since certain things (like pass index and current file name) cannot be conveyed in the ProgressManager? classes.
-The OnProgressChanged? event for the Task object will have the currently running erasure target as the sender instead of the task
-The old abstract Progress field in the ErasureTarget? has been replaced with a simple variable (for now, just for convenience)

Location:
branches/eraser6/SpeedMeter
Files:
8 edited

Legend:

Unmodified
Added
Removed
  • branches/eraser6/SpeedMeter/Eraser.Manager/DirectExecutor.cs

    r1502 r1503  
    364364            FileSystem fsManager = FileSystemManager.Get(volInfo); 
    365365 
    366             //Prepare our progress reporting machinery 
    367             TaskEventArgs eventArgs = new TaskEventArgs(task); 
    368             task.Progress.Start(); 
     366            //Start sampling the speed of the task. 
     367            SteppedProgressManager progress = new SteppedProgressManager(); 
     368            target.Progress = progress; 
     369            task.Progress.Steps.Add(new SteppedProgressManager.Step( 
     370                progress, 1.0f / task.Targets.Count)); 
    369371 
    370372            //Erase the cluster tips of every file on the drive. 
    371373            if (target.EraseClusterTips) 
    372374            { 
    373                 eventArgs.CurrentTargetStatus = S._("Searching for files' cluster tips..."); 
    374                 eventArgs.CurrentTargetTotalPasses = method.Passes; 
    375  
    376                 //Start counting statistics 
    377                 SteppedProgressManagerStep tipProgress = new SteppedProgressManagerStep(0.1f, 
    378                     S._("Erasing cluster tips...")); 
    379                 task.Progress.Steps.Add(tipProgress); 
    380                 tipProgress.Start(); 
    381                  
    382375                //Define the callback handlers 
     376                ProgressManager tipSearch = new ProgressManager(); 
     377                progress.Steps.Add(new SteppedProgressManager.Step(tipSearch,  
     378                    0.0f, S._("Searching for files' cluster tips..."))); 
     379                tipSearch.Total = 1; 
    383380                ClusterTipsSearchProgress searchProgress = delegate(string path) 
    384381                    { 
    385                         eventArgs.CurrentItemName = path; 
    386                         task.OnProgressChanged(eventArgs); 
     382                        if (currentTask.Canceled) 
     383                            throw new OperationCanceledException(S._("The task was cancelled.")); 
     384 
     385                        task.OnProgressChanged(target, new TaskProgressEventArgs(task, 
     386                            path, 0, 0)); 
     387                    }; 
     388 
     389                ProgressManager tipProgress = new ProgressManager(); 
     390                progress.Steps.Add(new SteppedProgressManager.Step(tipProgress, 0.1f, 
     391                    S._("Erasing cluster tips..."))); 
     392                ClusterTipsEraseProgress eraseProgress = 
     393                    delegate(int currentFile, int totalFiles, string currentFilePath) 
     394                    { 
     395                        tipSearch.Completed = tipSearch.Total; 
     396                        tipProgress.Total = totalFiles; 
     397                        tipProgress.Completed = currentFile; 
     398                        task.OnProgressChanged(target, new TaskProgressEventArgs(task, 
     399                            currentFilePath, 0, 0)); 
    387400 
    388401                        if (currentTask.Canceled) 
     
    390403                    }; 
    391404 
    392                 ClusterTipsEraseProgress eraseProgress = 
    393                     delegate(int currentFile, int totalFiles, string currentFilePath) 
    394                     { 
    395                         tipProgress.Total = totalFiles; 
    396                         tipProgress.Completed = currentFile; 
    397  
    398                         eventArgs.CurrentItemName = currentFilePath; 
    399                         task.OnProgressChanged(eventArgs); 
    400  
    401                         if (currentTask.Canceled) 
    402                             throw new OperationCanceledException(S._("The task was cancelled.")); 
    403                     }; 
    404  
     405                //Start counting statistics 
     406                tipProgress.Start(); 
    405407                fsManager.EraseClusterTips(VolumeInfo.FromMountpoint(target.Drive), 
    406408                    method, task.Log, searchProgress, eraseProgress); 
     
    416418                    Eraser.Util.File.SetCompression(info.FullName, false); 
    417419 
    418                 SteppedProgressManagerStep progress = new SteppedProgressManagerStep( 
    419                     target.EraseClusterTips ? 0.9f : 0.8f, S._("Erasing unused space...")); 
    420                 task.Progress.Steps.Add(progress); 
     420                ProgressManager mainProgress = new ProgressManager(); 
     421                progress.Steps.Add(new SteppedProgressManager.Step(mainProgress, 
     422                    target.EraseClusterTips ? 0.9f : 0.8f, S._("Erasing unused space..."))); 
     423                mainProgress.Start(); 
    421424 
    422425                //Continue creating files while there is free space. 
    423                 eventArgs.CurrentItemName = target.Drive; 
    424                 task.OnProgressChanged(eventArgs); 
    425                 progress.Start(); 
    426  
    427426                while (volInfo.AvailableFreeSpace > 0) 
    428427                { 
     
    460459                            delegate(long lastWritten, long totalData, int currentPass) 
    461460                            { 
    462                                 progress.Completed += lastWritten; 
    463                                 progress.Total = totalData; 
    464                                 eventArgs.CurrentItemPass = currentPass; 
    465                                 task.OnProgressChanged(eventArgs); 
     461                                mainProgress.Completed += lastWritten; 
     462                                mainProgress.Total = totalData; 
     463                                task.OnProgressChanged(target, new TaskProgressEventArgs(task, 
     464                                    target.Drive, currentPass, method.Passes)); 
    466465 
    467466                                if (currentTask.Canceled) 
     
    473472 
    474473                //Erase old resident file system table files 
    475                 eventArgs.CurrentItemName = S._("Old resident file system table files"); 
    476                 task.OnProgressChanged(eventArgs); 
    477  
    478                 SteppedProgressManagerStep residentProgress = new SteppedProgressManagerStep(0.05f); 
    479                 task.Progress.Steps.Add(residentProgress); 
     474                ProgressManager residentProgress = new ProgressManager(); 
     475                progress.Steps.Add(new SteppedProgressManager.Step(residentProgress, 
     476                    0.05f, S._("Old resident file system table files"))); 
    480477                residentProgress.Start(); 
    481478                fsManager.EraseOldFileSystemResidentFiles(volInfo, info, method, 
     
    484481                        residentProgress.Completed = currentFile; 
    485482                        residentProgress.Total = totalFiles; 
    486                         task.OnProgressChanged(eventArgs); 
     483                        task.OnProgressChanged(target, new TaskProgressEventArgs(task, 
     484                            string.Empty, 0, 0)); 
    487485 
    488486                        if (currentTask.Canceled) 
     
    494492            { 
    495493                //Remove the folder holding all our temporary files. 
    496                 eventArgs.CurrentTargetStatus = S._("Removing temporary files..."); 
    497                 task.OnProgressChanged(eventArgs); 
     494                ProgressManager tempFiles = new ProgressManager(); 
     495                progress.Steps.Add(new SteppedProgressManager.Step(tempFiles, 
     496                    0.0f, S._("Removing temporary files..."))); 
     497                task.OnProgressChanged(target, new TaskProgressEventArgs(task, string.Empty, 0, 0)); 
    498498                fsManager.DeleteFolder(info); 
    499499            } 
    500500 
    501501            //Then clean the old file system entries 
    502             SteppedProgressManagerStep structureProgress = 
    503                 new SteppedProgressManagerStep(0.05f, S._("Erasing unused directory structures...")); 
    504             task.Progress.Steps.Add(structureProgress); 
     502            ProgressManager structureProgress = new ProgressManager(); 
     503            progress.Steps.Add(new SteppedProgressManager.Step(structureProgress, 
     504                0.05f, S._("Erasing unused directory structures..."))); 
    505505            structureProgress.Start(); 
    506506            fsManager.EraseDirectoryStructures(volInfo, 
     
    515515 
    516516                    //Set the event parameters, then broadcast the progress event. 
    517                     task.OnProgressChanged(eventArgs); 
     517                    task.OnProgressChanged(target, new TaskProgressEventArgs(task, 
     518                        string.Empty, 0, 0)); 
    518519                } 
    519520            ); 
     521 
     522            target.Progress = null; 
    520523        } 
    521524 
     
    541544            TaskEventArgs eventArgs = new TaskEventArgs(task); 
    542545            SteppedProgressManager progress = new SteppedProgressManager(); 
     546            target.Progress = progress; 
     547            task.Progress.Steps.Add(new SteppedProgressManager.Step(progress, 1.0f / task.Targets.Count)); 
    543548 
    544549            //Iterate over every path, and erase the path. 
     
    546551            { 
    547552                //Update the task progress 
    548                 SteppedProgressManagerStep step = new SteppedProgressManagerStep( 
    549                     i / (float)paths.Count, S._("Erasing files...")); 
    550                 eventArgs.CurrentTarget = target; 
    551                 eventArgs.CurrentItemName = paths[i]; 
    552                 eventArgs.CurrentItemProgress = 0; 
    553                 eventArgs.CurrentTargetTotalPasses = method.Passes; 
    554                 task.OnProgressChanged(eventArgs); 
     553                ProgressManager step = new ProgressManager(); 
     554                progress.Steps.Add(new SteppedProgressManager.Step(step, 
     555                    i / (float)paths.Count, S._("Erasing files..."))); 
     556                task.OnProgressChanged(target, new TaskProgressEventArgs( 
     557                    task, paths[i], 0, method.Passes)); 
    555558                 
    556559                //Get the filesystem provider to handle the secure file erasures 
     
    587590                    } 
    588591 
    589                     long itemWritten = 0; 
    590592                    fsManager.EraseFileSystemObject(info, method, 
    591593                        delegate(long lastWritten, long totalData, int currentPass) 
    592594                        { 
     595                            if (currentTask.Canceled) 
     596                                throw new OperationCanceledException(S._("The task was cancelled.")); 
     597 
    593598                            step.Completed += lastWritten; 
    594599                            step.Total = totalData; 
    595                             eventArgs.CurrentItemPass = currentPass; 
    596                             task.OnProgressChanged(eventArgs); 
    597  
    598                             if (currentTask.Canceled) 
    599                                 throw new OperationCanceledException(S._("The task was cancelled.")); 
     600                            task.OnProgressChanged(target, new TaskProgressEventArgs(task, 
     601                                info.FullName, currentPass, method.Passes)); 
    600602                        }); 
    601603 
     
    641643            if (target is FolderTarget) 
    642644            { 
    643                 eventArgs.CurrentTargetStatus = S._("Removing folders..."); 
     645                ProgressManager step = new ProgressManager(); 
     646                progress.Steps.Add(new SteppedProgressManager.Step(step, 
     647                    0.0f, S._("Removing folders..."))); 
    644648                 
    645649                //Remove all subfolders which are empty. 
     
    651655                     foreach (DirectoryInfo subDir in info.GetDirectories()) 
    652656                         eraseEmptySubFolders(subDir); 
    653  
    654                      eventArgs.CurrentItemName = info.FullName; 
    655                      task.OnProgressChanged(eventArgs); 
     657                     task.OnProgressChanged(target, new TaskProgressEventArgs( 
     658                         task, info.FullName, 0, 0)); 
    656659 
    657660                     FileSystemInfo[] files = info.GetFileSystemInfos(); 
     
    664667                { 
    665668                    DirectoryInfo info = new DirectoryInfo(fldr.Path); 
    666                     eventArgs.CurrentItemName = info.FullName; 
    667                     task.OnProgressChanged(eventArgs); 
     669                    task.OnProgressChanged(target, new TaskProgressEventArgs( 
     670                         task, info.FullName, 0, 0)); 
    668671 
    669672                    //See if this is the root of a volume. 
     
    679682                        fsManager.DeleteFolder(info); 
    680683                } 
     684 
     685                target.Progress = null; 
    681686            } 
    682687 
     
    684689            if (target is RecycleBinTarget) 
    685690            { 
    686                 eventArgs.CurrentTargetStatus = S._("Emptying recycle bin..."); 
    687                 task.OnProgressChanged(eventArgs); 
     691                ProgressManager step = new ProgressManager(); 
     692                progress.Steps.Add(new SteppedProgressManager.Step(step, 
     693                    0.0f, S._("Emptying recycle bin..."))); 
     694                task.OnProgressChanged(target, new TaskProgressEventArgs(task, string.Empty, 0, 0)); 
    688695 
    689696                ShellApi.EmptyRecycleBin(EmptyRecycleBinOptions.NoConfirmation | 
  • branches/eraser6/SpeedMeter/Eraser.Manager/ProgressManager.cs

    r1502 r1503  
    180180 
    181181    /// <summary> 
    182     /// Represents one step of the steps associated with the <see cref="SteppedProgressManager"/> 
    183     /// </summary> 
    184     public class SteppedProgressManagerStep : ProgressManager 
    185     { 
    186         /// <summary> 
    187         /// Constructor. 
    188         /// </summary> 
    189         /// <param name="weight">The weight of this step. The weight is a decimal 
    190         /// number in the range [0.0, 1.0] which represents the percentage of the 
    191         /// entire process this particular step is.</param> 
    192         /// <param name="name">A user-specified value of the name of this step. 
    193         /// This value is not used by the class at all.</param> 
    194         public SteppedProgressManagerStep(float weight, string name) 
    195         { 
    196             Weight = weight; 
    197             Name = name; 
    198         } 
    199  
    200         /// <summary> 
    201         /// The weight associated with this step. 
    202         /// </summary> 
    203         public float Weight 
    204         { 
    205             get; 
    206             private set; 
    207         } 
    208  
    209         /// <summary> 
    210         /// The name of this step. 
    211         /// </summary> 
    212         public string Name 
    213         { 
    214             get; 
    215             set; 
    216         } 
    217  
    218         /// <summary> 
    219         /// The <see cref="SteppedProgressManager"/> which manages this step. 
    220         /// </summary> 
    221         internal SteppedProgressManager Manager 
    222         { 
    223             get; 
    224             set; 
    225         } 
    226     } 
    227  
    228     /// <summary> 
    229182    /// Manages progress based on sub-tasks, taking each sub-task to be a step 
    230183    /// in which the next step will not be executed until the current step is 
     
    236189    { 
    237190        /// <summary> 
     191        /// Represents one step in the list of steps to complete. 
     192        /// </summary> 
     193        public class Step 
     194        { 
     195            /// <summary> 
     196            /// Constructor. 
     197            /// </summary> 
     198            /// <param name="progress">The <see cref="ProgressManagerBase"/> instance 
     199            /// which measures the progress of this step.</param> 
     200            /// <param name="weight">The weight of this step. The weight is a decimal 
     201            /// number in the range [0.0, 1.0] which represents the percentage of the 
     202            /// entire process this particular step is.</param> 
     203            public Step(ProgressManagerBase progress, float weight) 
     204                : this(progress, weight, null) 
     205            { 
     206            } 
     207 
     208            /// <summary> 
     209            /// Constructor. 
     210            /// </summary> 
     211            /// <param name="progress">The <see cref="ProgressManagerBase"/> instance 
     212            /// which measures the progress of this step.</param> 
     213            /// <param name="weight">The weight of this step. The weight is a decimal 
     214            /// number in the range [0.0, 1.0] which represents the percentage of the 
     215            /// entire process this particular step is.</param> 
     216            /// <param name="name">A user-specified value of the name of this step. 
     217            /// This value is not used by the class at all.</param> 
     218            public Step(ProgressManagerBase progress, float weight, string name) 
     219            { 
     220                Progress = progress; 
     221                Weight = weight; 
     222                Name = name; 
     223            } 
     224 
     225            /// <summary> 
     226            /// The <see cref="ProgressManagerBase"/> instance which measures the 
     227            /// progress of the step. 
     228            /// </summary> 
     229            public ProgressManagerBase Progress 
     230            { 
     231                get; 
     232                set; 
     233            } 
     234 
     235            /// <summary> 
     236            /// The weight associated with this step. 
     237            /// </summary> 
     238            public float Weight 
     239            { 
     240                get; 
     241                private set; 
     242            } 
     243 
     244            /// <summary> 
     245            /// The name of this step. 
     246            /// </summary> 
     247            public string Name 
     248            { 
     249                get; 
     250                set; 
     251            } 
     252        } 
     253 
     254        /// <summary> 
    238255        /// The class which manages the steps which comprise the overall progress. 
    239256        /// </summary> 
    240         public class StepsList : IList<SteppedProgressManagerStep> 
     257        public class StepsList : IList<Step> 
    241258        { 
    242259            public StepsList(SteppedProgressManager manager) 
    243260            { 
    244                 List = new List<SteppedProgressManagerStep>(); 
     261                List = new List<Step>(); 
    245262                Manager = manager; 
    246263            } 
    247264 
    248             #region IList<SteppedProgressManagerStep> Members 
    249  
    250             public int IndexOf(SteppedProgressManagerStep item) 
     265            #region IList<Step> Members 
     266 
     267            public int IndexOf(Step item) 
    251268            { 
    252269                return List.IndexOf(item); 
    253270            } 
    254271 
    255             public void Insert(int index, SteppedProgressManagerStep item) 
    256             { 
    257                 if (item.Manager != null) 
    258                     throw new ArgumentException("The step cannot be added to " + 
    259                         "multiple SteppedProgressManager instances simultaneously."); 
    260  
     272            public void Insert(int index, Step item) 
     273            { 
    261274                List.Insert(index, item); 
    262                 item.Manager = Manager; 
    263275                TotalWeights += item.Weight; 
    264276            } 
     
    267279            { 
    268280                TotalWeights -= List[index].Weight; 
    269                 List[index].Manager = null; 
    270281                List.RemoveAt(index); 
    271282            } 
    272283 
    273             public SteppedProgressManagerStep this[int index] 
     284            public Step this[int index] 
    274285            { 
    275286                get 
     
    280291                { 
    281292                    TotalWeights -= List[index].Weight; 
    282                     List[index].Manager = null; 
    283  
    284293                    List[index] = value; 
    285294                    TotalWeights += value.Weight; 
    286                     value.Manager = Manager; 
    287295                } 
    288296            } 
     
    290298            #endregion 
    291299 
    292             #region ICollection<SteppedProgressManagerStep> Members 
    293  
    294             public void Add(SteppedProgressManagerStep item) 
     300            #region ICollection<Step> Members 
     301 
     302            public void Add(Step item) 
    295303            { 
    296304                List.Add(item); 
    297305                TotalWeights += item.Weight; 
    298                 item.Manager = Manager; 
    299306            } 
    300307 
    301308            public void Clear() 
    302309            { 
    303                 foreach (SteppedProgressManagerStep step in List) 
    304                     step.Manager = null; 
    305  
    306310                List.Clear(); 
    307311                TotalWeights = 0; 
    308312            } 
    309313 
    310             public bool Contains(SteppedProgressManagerStep item) 
     314            public bool Contains(Step item) 
    311315            { 
    312316                return List.Contains(item); 
    313317            } 
    314318 
    315             public void CopyTo(SteppedProgressManagerStep[] array, int arrayIndex) 
     319            public void CopyTo(Step[] array, int arrayIndex) 
    316320            { 
    317321                List.CopyTo(array, arrayIndex); 
     
    328332            } 
    329333 
    330             public bool Remove(SteppedProgressManagerStep item) 
     334            public bool Remove(Step item) 
    331335            { 
    332336                int index = List.IndexOf(item); 
    333337                if (index != -1) 
    334                 { 
    335338                    TotalWeights -= List[index].Weight; 
    336                     List[index].Manager = null; 
    337                 } 
    338339 
    339340                return List.Remove(item); 
     
    342343            #endregion 
    343344 
    344             #region IEnumerable<SteppedProgressManagerStep> Members 
    345  
    346             public IEnumerator<SteppedProgressManagerStep> GetEnumerator() 
     345            #region IEnumerable<Step> Members 
     346 
     347            public IEnumerator<Step> GetEnumerator() 
    347348            { 
    348349                return List.GetEnumerator(); 
     
    382383            /// The list storing the steps for this instance. 
    383384            /// </summary> 
    384             private List<SteppedProgressManagerStep> List; 
     385            private List<Step> List; 
    385386 
    386387            /// <summary> 
     
    410411                float result = 0.0f; 
    411412 
    412                 foreach (SteppedProgressManagerStep step in Steps) 
    413                     result += step.Progress * step.Weight; 
     413                foreach (Step step in Steps) 
     414                    result += step.Progress.Progress * step.Weight; 
    414415 
    415416                return result; 
     
    421422            get 
    422423            { 
    423                 throw new NotSupportedException(); 
     424                return CurrentStep.Progress.Speed; 
    424425            } 
    425426        } 
     
    449450        /// no steps are executing (also when the task is complete) 
    450451        /// </summary> 
    451         public SteppedProgressManagerStep CurrentStep 
     452        public Step CurrentStep 
    452453        { 
    453454            get 
     
    456457                    return null; 
    457458 
    458                 foreach (SteppedProgressManagerStep step in Steps) 
    459                     if (step.Progress < 1.0f) 
     459                foreach (Step step in Steps) 
     460                    if (step.Progress.Progress < 1.0f) 
    460461                        return step; 
    461462 
     
    597598            { 
    598599                float result = 0.0f; 
    599                 foreach (SteppedProgressManagerStep step in Tasks) 
    600                     result += step.Progress * (1.0f / Tasks.Count); 
     600                foreach (ProgressManagerBase subTask in Tasks) 
     601                    result += subTask.Progress * (1.0f / Tasks.Count); 
    601602 
    602603                return result; 
     
    609610            { 
    610611                int maxSpeed = 0; 
    611                 foreach (SteppedProgressManagerStep step in Tasks) 
    612                     maxSpeed = Math.Max(step.Speed, maxSpeed); 
     612                foreach (ProgressManagerBase subTask in Tasks) 
     613                    maxSpeed = Math.Max(subTask.Speed, maxSpeed); 
    613614 
    614615                return maxSpeed; 
     
    621622            { 
    622623                TimeSpan maxTime = TimeSpan.MinValue; 
    623                 foreach (SteppedProgressManagerStep step in Tasks) 
    624                     if (maxTime < step.TimeLeft) 
    625                         maxTime = step.TimeLeft; 
     624                foreach (ProgressManagerBase subTask in Tasks) 
     625                    if (maxTime < subTask.TimeLeft) 
     626                        maxTime = subTask.TimeLeft; 
    626627 
    627628                return maxTime; 
  • branches/eraser6/SpeedMeter/Eraser.Manager/Strings.en.resx

    r1502 r1503  
    136136    <value>Searching for files' cluster tips...</value> 
    137137  </data> 
     138  <data name="The task was cancelled." xml:space="preserve"> 
     139    <value>The task was cancelled.</value> 
     140  </data> 
    138141  <data name="Erasing cluster tips..." xml:space="preserve"> 
    139142    <value>Erasing cluster tips...</value> 
    140143  </data> 
    141   <data name="The task was cancelled." xml:space="preserve"> 
    142     <value>The task was cancelled.</value> 
    143   </data> 
    144144  <data name="Erasing unused space..." xml:space="preserve"> 
    145145    <value>Erasing unused space..</value> 
  • branches/eraser6/SpeedMeter/Eraser.Manager/Strings.it.resx

    r1502 r1503  
    136136    <value>Ricerca dei cluster tips dei files...</value> 
    137137  </data> 
     138  <data name="The task was cancelled." xml:space="preserve"> 
     139    <value>L'operazione è stata cancellata.</value> 
     140  </data> 
    138141  <data name="Erasing cluster tips..." xml:space="preserve"> 
    139142    <value>Pulizia dei cluster tips...</value> 
    140143  </data> 
    141   <data name="The task was cancelled." xml:space="preserve"> 
    142     <value>L'operazione è stata cancellata.</value> 
    143   </data> 
    144144  <data name="Erasing unused space..." xml:space="preserve"> 
    145145    <value>Pulizia dello spazioni non usato...</value> 
  • branches/eraser6/SpeedMeter/Eraser.Manager/Strings.nl.resx

    r1502 r1503  
    136136    <value>(Untranslated)</value> 
    137137  </data> 
     138  <data name="The task was cancelled." xml:space="preserve"> 
     139    <value>(Untranslated)</value> 
     140  </data> 
    138141  <data name="Erasing cluster tips..." xml:space="preserve"> 
    139142    <value>(Untranslated)</value> 
    140143  </data> 
    141   <data name="The task was cancelled." xml:space="preserve"> 
    142     <value>(Untranslated)</value> 
    143   </data> 
    144144  <data name="Erasing unused space..." xml:space="preserve"> 
    145145    <value>(Untranslated)</value> 
  • branches/eraser6/SpeedMeter/Eraser.Manager/Strings.resx

    r1502 r1503  
    136136    <value>Searching for files' cluster tips...</value> 
    137137  </data> 
     138  <data name="The task was cancelled." xml:space="preserve"> 
     139    <value>The task was cancelled.</value> 
     140  </data> 
    138141  <data name="Erasing cluster tips..." xml:space="preserve"> 
    139142    <value>Erasing cluster tips...</value> 
    140143  </data> 
    141   <data name="The task was cancelled." xml:space="preserve"> 
    142     <value>The task was cancelled.</value> 
    143   </data> 
    144144  <data name="Erasing unused space..." xml:space="preserve"> 
    145145    <value>Erasing unused space...</value> 
  • branches/eraser6/SpeedMeter/Eraser.Manager/Task.cs

    r1502 r1503  
    235235        /// The event object holding all event handlers. 
    236236        /// </summary> 
    237         public EventHandler<TaskEventArgs> ProgressChanged { get; set; } 
     237        public EventHandler<TaskProgressEventArgs> ProgressChanged { get; set; } 
    238238 
    239239        /// <summary> 
     
    266266        /// Broadcasts a ProgressChanged event. 
    267267        /// </summary> 
     268        /// <param name="sender">The <see cref="ErasureTarget"/> which is reporting 
     269        /// progress.</param> 
    268270        /// <param name="e">The new progress value.</param> 
    269         internal void OnProgressChanged(TaskEventArgs e) 
     271        internal void OnProgressChanged(ErasureTarget sender, TaskProgressEventArgs e) 
    270272        { 
    271273            if (ProgressChanged != null) 
    272                 ProgressChanged(this, e); 
     274                ProgressChanged(sender, e); 
    273275        } 
    274276 
     
    367369 
    368370        /// <summary> 
    369         /// Gets the progress for this target. If this target is not currently 
    370         /// executing or if the target has completed, this property will return 
    371         /// null. 
    372         /// </summary> 
    373         public abstract ProgressManagerBase Progress 
     371        /// Erasure method to use for the target. 
     372        /// </summary> 
     373        private ErasureMethod method; 
     374 
     375        /// <summary> 
     376        /// The progress of this target. 
     377        /// </summary> 
     378        public ProgressManagerBase Progress 
    374379        { 
    375380            get; 
    376             protected set; 
    377         } 
    378  
    379         /// <summary> 
    380         /// Erasure method to use for the target. 
    381         /// </summary> 
    382         private ErasureMethod method; 
     381            internal set; 
     382        } 
    383383    } 
    384384 
     
    571571        /// </summary> 
    572572        public bool EraseClusterTips { get; set; } 
    573  
    574         public override ProgressManagerBase Progress 
    575         { 
    576             get 
    577             { 
    578                 return new ProgressManager(); 
    579             } 
    580             protected set 
    581             { 
    582                 throw new NotImplementedException(); 
    583             } 
    584         } 
    585573    } 
    586574 
     
    619607            result.Add(Path); 
    620608            return result; 
    621         } 
    622  
    623         public override ProgressManagerBase Progress 
    624         { 
    625             get 
    626             { 
    627                 return new ProgressManager(); 
    628             } 
    629             protected set 
    630             { 
    631                 throw new NotImplementedException(); 
    632             } 
    633609        } 
    634610    } 
     
    766742        /// </summary> 
    767743        public bool DeleteIfEmpty { get; set; } 
    768  
    769         public override ProgressManagerBase Progress 
    770         { 
    771             get 
    772             { 
    773                 return new SteppedProgressManager(); 
    774             } 
    775             protected set 
    776             { 
    777                 throw new NotImplementedException(); 
    778             } 
    779         } 
    780744    } 
    781745 
     
    862826            } 
    863827        } 
    864  
    865         public override ProgressManagerBase Progress 
    866         { 
    867             get 
    868             { 
    869                 return new SteppedProgressManager(); 
    870             } 
    871             protected set 
    872             { 
    873                 throw new NotImplementedException(); 
    874             } 
    875         } 
    876828    } 
    877829 
     
    10581010        public Task Task { get; private set; } 
    10591011    } 
     1012 
     1013    public class TaskProgressEventArgs : TaskEventArgs 
     1014    { 
     1015        /// <summary> 
     1016        /// Constructor. 
     1017        /// </summary> 
     1018        /// <param name="task">The task being referred to by this event.</param> 
     1019        /// <param name="itemName">The item whose erasure progress is being erased.</param> 
     1020        /// <param name="itemPass">The current pass number for this item.</param> 
     1021        /// <param name="itemTotalPasses">The total number of passes to complete erasure 
     1022        /// of this item.</param> 
     1023        public TaskProgressEventArgs(Task task, string itemName, int itemPass, 
     1024            int itemTotalPasses) 
     1025            : base(task) 
     1026        { 
     1027            ItemName = itemName; 
     1028            ItemPass = itemPass; 
     1029            ItemTotalPasses = itemTotalPasses; 
     1030        } 
     1031 
     1032        /// <summary> 
     1033        /// The file name of the item being erased. 
     1034        /// </summary> 
     1035        public string ItemName { get; private set; } 
     1036 
     1037        /// <summary> 
     1038        /// The pass number of a multi-pass erasure method. 
     1039        /// </summary> 
     1040        public int ItemPass { get; private set; } 
     1041 
     1042        /// <summary> 
     1043        /// The total number of passes to complete before this erasure method is 
     1044        /// completed. 
     1045        /// </summary> 
     1046        public int ItemTotalPasses { get; private set; } 
     1047    } 
    10601048} 
  • branches/eraser6/SpeedMeter/Eraser/ProgressForm.cs

    r1502 r1503  
    5959        } 
    6060 
    61         private void task_ProgressChanged(object sender, TaskEventArgs e) 
     61        private void task_ProgressChanged(object sender, TaskProgressEventArgs e) 
    6262        { 
    6363            if (InvokeRequired) 
     
    6868 
    6969                lastUpdate = DateTime.Now; 
    70                 Invoke(new EventHandler<TaskEventArgs>(task_ProgressChanged), sender, e); 
     70                Invoke(new EventHandler<TaskProgressEventArgs>(task_ProgressChanged), sender, e); 
    7171                return; 
    7272            } 
    7373 
    74             status.Text = e.CurrentTargetStatus; 
    75             item.Text = WrapItemName(e.CurrentItemName); 
    76             pass.Text = e.CurrentTargetTotalPasses != 0 ? 
    77                 S._("{0} out of {1}", e.CurrentItemPass, e.CurrentTargetTotalPasses) : 
    78                 e.CurrentItemPass.ToString(CultureInfo.CurrentCulture); 
     74            ErasureTarget target = sender as ErasureTarget; 
     75            SteppedProgressManager progress = target.Progress as SteppedProgressManager; 
     76            status.Text = progress.CurrentStep.Name; 
     77            item.Text = WrapItemName(e.ItemName); 
     78            pass.Text = e.ItemTotalPasses != 0 ? 
     79                S._("{0} out of {1}", e.ItemPass, e.ItemTotalPasses) : 
     80                e.ItemPass.ToString(CultureInfo.CurrentCulture); 
    7981 
    80             if (e.TimeLeft >= TimeSpan.Zero) 
    81                 timeLeft.Text = S._("About {0:T} left", e.TimeLeft); 
     82            if (target.Progress.TimeLeft >= TimeSpan.Zero) 
     83                timeLeft.Text = S._("About {0:T} left", target.Progress.TimeLeft); 
    8284            else 
    8385                timeLeft.Text = S._("Unknown"); 
    8486 
    85             if (e.CurrentItemProgress >= 0.0f) 
     87            if (target.Progress.Progress >= 0.0f) 
    8688            { 
    8789                itemProgress.Style = ProgressBarStyle.Continuous; 
    88                 itemProgress.Value = (int)(e.CurrentItemProgress * 1000); 
    89                 itemProgressLbl.Text = e.CurrentItemProgress.ToString("#0%", 
     90                itemProgress.Value = (int)(target.Progress.Progress * 1000); 
     91                itemProgressLbl.Text = target.Progress.Progress.ToString("#0%", 
    9092                    CultureInfo.CurrentCulture); 
    9193            } 
Note: See TracChangeset for help on using the changeset viewer.